package com.sg.service.biz.app.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.exception.Assert;
import com.sg.common.exception.BizException;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.app.req.*;
import com.sg.dto.biz.app.common.EvalTempDto;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.dto.integration.app.EvalThemeDto;
import com.sg.dto.integration.component.*;
import com.sg.dto.integration.component.ConfSchemeItemResultDto;
import com.sg.dto.integration.component.QueryConfItemMatchAnswerDetailComReqDto;
import com.sg.dto.integration.component.QueryConfItemMatchAnswerListComReqDto;
import com.sg.dto.integration.framework.*;
import com.sg.entity.*;
import com.sg.service.base.app.*;
import com.sg.service.biz.app.*;
import com.sg.service.biz.app.nb.NbEvaTheme;
import com.wicket.okrcomponent.integration.ConfSchemeService;
import com.wicket.okrcomponent.integration.FwCompEvaThemeClient;
import com.wicket.okrcomponent.integration.SchemeOpenRecordService;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.stream.Collectors;


/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class EvaThemeServiceImpl implements EvaThemeService {
    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsEvaluationSubjectService mOmsEvaluationSubjectService;
    @Resource
    private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
    //@Resource
    //private MOmsConfSchemeOptionResultService mOmsConfSchemeOptionResultService;
    @Resource
    private MOmsEvaluationPortraitService mOmsEvaluationPortraitService;
    @Resource
    private MOmsEvaluationObjectService mOmsEvaluationObjectService;
    @Resource
    private MOmsEvaluationFillRoleService mOmsEvaluationFillRoleService;
    @Resource
    private NbEvaTheme nbEvaTheme;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private SchemeOpenRecordService fwCompSchemeOpenRecordClient;
    @Resource
    private MOmsTargetService mOmsTargetService;
    @Resource
    private RoleService fwBaseRoleClient;
    @Resource
    private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
    //@Resource
    //private MSpecMethordTableService mSpecMethordTableService;
    @Resource
    private MOmsBizAppBatchService mOmsBizAppBatchService;
    @Resource
    private OffStateService offStateService;
    @Resource
    private PlanDataService planDataService;
    @Resource
    private MOmsVirtualOrgService mOmsVirtualOrgService;
    @Resource
    private MOmsVirtualOrgMemberDeptService mOmsVirtualOrgMemberDeptService;
    @Resource
    private MOmsVirtualOrgMemberService mOmsVirtualOrgMemberService;
    @Resource
    private InductionRecordService inductionRecordService;
    @Resource
    private PowerService powerService;
    @Resource
    private MOmsEvaluationFillMemberService mOmsEvaluationFillMemberService;
    @Resource
    private BatchService batchService;
    @Resource
    private IndexSystemService indexSystemService;
    @Resource
    private VirtualOrgService virtualOrgService;
    @Resource
    private TargetCycleService targetCycleService;
    @Resource
    private TaskGenService taskGenService;
    @Resource
    private BaseService baseService;
    //@Resource
    //private undefinedService undefinedService;
    @Resource
    private MOmsTargetTimingTaskDispatchService mOmsTargetTimingTaskDispatchService;
    @Resource
    private MOmsBasicInstanceAssistBehaviorCurrentStepService mOmsBasicInstanceAssistBehaviorCurrentStepService;
    @Resource
    private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
    @Resource
    private MOmsTargetObjectivePlanExtendService mOmsTargetObjectivePlanExtendService;
    @Resource
    private MOmsAssistNodeStatusService mOmsAssistNodeStatusService;
    @Resource
    private TimingTaskService timingTaskService;
    @Resource
    private FwCompEvaThemeClient fwCompEvaThemeClient;
    @Resource
    private MOmsTargetObjectiveService mOmsTargetObjectiveService;
    @Resource
    private FwBaseSecurityClient fwBaseSecurityClient;
    @Resource
    private CustomExecutionCycleService customExecutionCycleService;
    @Resource
    private MOmsTaskService mOmsTaskService;
//@Resource
    //private MCustomFields2Service mCustomFields2Service;
//@Resource
//  private CustomExecutionCycleService customExecutionCycleService;


    /**
     * D3-2批量查询评价主题列表[2146]
     * gen by moon at 11/9/2022, 1:00:46 AM
     */
    @Trace(operationName = "D3-2批量查询评价主题列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryEvaThemeListRespDto batchQueryEvaThemeList(BatchQueryEvaThemeListReqDto reqDto) {


        List<OmsEvaluationSubject> listOmsEvaluationSubject_1 = new ArrayList<>();
//步骤0: 3-2-02批量查询评价主题列表 - batchQueryEvaThemeList
        List<OmsEvaluationSubject> listOmsEvaluationSubject = new ArrayList<>();
        BatchQueryEvaThemeListReq batchQueryEvaThemeListReq = new BatchQueryEvaThemeListReq();
        if (reqDto != null) {
            batchQueryEvaThemeListReq.setEvalThemeList(reqDto.getEvalThemeList());//list-field-assign//sourceId:62418_1
            batchQueryEvaThemeListReq.setAscriptionSpaceId(reqDto.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:62417_1
            batchQueryEvaThemeListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:258695_1
        }

        /*3-2-02批量查询评价主题列表[2144]   */
        Assert.isNull(batchQueryEvaThemeListReq.getAscriptionSpaceId(), "D3-2批量查询评价主题列表-3-2-02批量查询评价主题列表-归属空间ID不能为空", false);
        listOmsEvaluationSubject = mOmsEvaluationSubjectService.batchQueryEvaThemeList(batchQueryEvaThemeListReq);


        listOmsEvaluationSubject_1 = listOmsEvaluationSubject;

        BatchQueryEvaThemeListRespDto retData = new BatchQueryEvaThemeListRespDto();
        retData.setEvalThemeList(listOmsEvaluationSubject_1.stream().map(item -> BeanUtil.toBean(item, EvalThemeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:62422_1


        return retData;
    }

    /**
     * D3-2修改评价主题[3086]
     * gen by moon at 5/24/2023, 3:54:04 AM
     */
    @Trace(operationName = "D3-2修改评价主题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateEvaThemeRespDto updateEvaTheme(UpdateEvaThemeReqDto reqDto) {


        //virtualUsage D2-3查配置方案标识  40211
        QueryConfSchemeDetailComRespDto queryConfSchemeDetailComRespDto = null;
        QueryConfSchemeDetailComReqDto queryConfSchemeDetailComReqDto = new QueryConfSchemeDetailComReqDto();
        queryConfSchemeDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:900849_1_40211
        if (reqDto != null) {
            queryConfSchemeDetailComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:900830_1_40211
        }

        /*D2-3查配置方案标识[1981]   */
        Assert.isNull(queryConfSchemeDetailComReqDto.getConfSchemeId(), "D3-2修改评价主题-D2-3查配置方案标识-配置方案ID 不能为空", false);
        Assert.isNull(queryConfSchemeDetailComReqDto.getSubjectLifeCycle(), "D3-2修改评价主题-D2-3查配置方案标识-生命周期状态不能为空", false);
        queryConfSchemeDetailComRespDto = confSchemeService.queryConfSchemeDetailCom(queryConfSchemeDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D2-3查主题配置方案基础分组标准答案  40210
        QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
        QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto = new QueryClassMatchResultToAnswerDetailComReqDto();
        queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("THEME_BASIC_SET_CLASS");//CUSTOM_CONVENTION//sourceId:900740_1_40210
        queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:900819_1_40210
        if (reqDto != null) {
            queryClassMatchResultToAnswerDetailComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:900829_1_40210
        }

        /*D2-3查主题配置方案基础分组标准答案[3088]   */
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfSchemeId(), "D3-2修改评价主题-D2-3查主题配置方案基础分组标准答案-配置方案ID 不能为空", false);
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(), "D3-2修改评价主题-D2-3查主题配置方案基础分组标准答案-分组标识不能为空", false);
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(), "D3-2修改评价主题-D2-3查主题配置方案基础分组标准答案-是否标准答案不能为空", false);
        queryClassMatchResultToAnswerDetailComRespDto = confSchemeService.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage 3-2-01修改评价主题  19207
        boolean bOOLEAN;
        if (queryClassMatchResultToAnswerDetailComRespDto != null && queryConfSchemeDetailComRespDto != null) {
            OmsEvaluationSubject omsEvaluationSubject = new OmsEvaluationSubject();
            if (reqDto != null) {
                omsEvaluationSubject.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:104556_1_19207
                omsEvaluationSubject.setEvaluationSubjectName(reqDto.getEvaluationSubjectName());//SimpleFieldAssign//sourceId:104562_1_19207
                omsEvaluationSubject.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:900737_1_19207
                omsEvaluationSubject.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:104559_1_19207
            }
            if (queryClassMatchResultToAnswerDetailComRespDto != null) {
                omsEvaluationSubject.setBizSceneCode(queryClassMatchResultToAnswerDetailComRespDto.getBizSceneCode());//SimpleFieldAssign//sourceId:900735_1_19207
                omsEvaluationSubject.setEvaluationSubjectTypeCode(queryClassMatchResultToAnswerDetailComRespDto.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:900736_1_19207
            }
            if (queryConfSchemeDetailComRespDto != null) {
                omsEvaluationSubject.setConfSchemeCode(queryConfSchemeDetailComRespDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:900738_1_19207
            }

            /*3-2-01修改评价主题[2280]   */
            Assert.isNull(omsEvaluationSubject.getEvaluationSubjectId(), "D3-2修改评价主题-3-2-01修改评价主题-评价主题ID不能为空", false);
            bOOLEAN = mOmsEvaluationSubjectService.updateEvaTheme(omsEvaluationSubject)/*vcase invoke 本地 method 方法调用;*/;


        }
        if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))) {
            //if(D3-2修改评价主题.主体生命周期 等于 当前有效)  39964

            OmsEvaluationSubject omsEvaluationSubject_1 = null;
            QueryEvaThemeDetailReq queryEvaThemeDetailReq = new QueryEvaThemeDetailReq();
            if (reqDto != null) {
                queryEvaThemeDetailReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:900877_1_40214
            }

            /*3-2-01查评价主题[2310]   */
            Assert.isNull(queryEvaThemeDetailReq.getEvaluationSubjectId(), "D3-2修改评价主题-3-2-01查评价主题-评价主题ID不能为空", false);
            omsEvaluationSubject_1 = mOmsEvaluationSubjectService.queryEvaThemeDetail(queryEvaThemeDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            AddOpenRecordAuthorizationComRespDto addOpenRecordAuthorizationComRespDto = null;
            if (queryConfSchemeDetailComRespDto != null && queryClassMatchResultToAnswerDetailComRespDto != null && omsEvaluationSubject_1 != null) {
                AddOpenRecordAuthorizationComReqDto addOpenRecordAuthorizationComReqDto = new AddOpenRecordAuthorizationComReqDto();
                addOpenRecordAuthorizationComReqDto.setApplexType("EVA_THEME");//sourceId:900865_1_40212
                if (reqDto != null) {
                    addOpenRecordAuthorizationComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:900855_1_40212
                    addOpenRecordAuthorizationComReqDto.setAuthType(reqDto.getAuthType());//SimpleFieldAssign//sourceId:900857_1_40212
                    addOpenRecordAuthorizationComReqDto.setAuthorizationNum(reqDto.getRemainingQty());//SimpleFieldAssign//sourceId:900858_1_40212
                    addOpenRecordAuthorizationComReqDto.setAuthUnit(reqDto.getAuthUnit());//SimpleFieldAssign//sourceId:900859_1_40212
                    addOpenRecordAuthorizationComReqDto.setStartTime(reqDto.getStartTime());//SimpleFieldAssign//sourceId:900860_1_40212
                    addOpenRecordAuthorizationComReqDto.setEndTime(reqDto.getEndTime());//SimpleFieldAssign//sourceId:900861_1_40212
                    addOpenRecordAuthorizationComReqDto.setIsMainConfScheme(reqDto.getIsMainConfScheme());//SimpleFieldAssign//sourceId:900862_1_40212
                    addOpenRecordAuthorizationComReqDto.setApplexId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:900866_1_40212
                    addOpenRecordAuthorizationComReqDto.setApplexName(reqDto.getEvaluationSubjectName());//SimpleFieldAssign//sourceId:915057_1_40212
                    addOpenRecordAuthorizationComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:900864_1_40212
                }
                if (queryConfSchemeDetailComRespDto != null) {
                    addOpenRecordAuthorizationComReqDto.setConfSchemeCode(queryConfSchemeDetailComRespDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:900856_1_40212
                }
                if (queryClassMatchResultToAnswerDetailComRespDto != null) {
                    addOpenRecordAuthorizationComReqDto.setAuthorizationKeyTypeCode(queryClassMatchResultToAnswerDetailComRespDto.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:932183_1_40212
                }
                if (omsEvaluationSubject_1 != null) {
                    addOpenRecordAuthorizationComReqDto.setTenantSpaceId(omsEvaluationSubject_1.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:900863_1_40212
                }

                /*D2新增开通记录并授权(公共)[3102]   */
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getConfSchemeId(), "D3-2修改评价主题-D2新增开通记录并授权(公共)-配置方案ID 不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getConfSchemeCode(), "D3-2修改评价主题-D2新增开通记录并授权(公共)-配置方案标识不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getIsMainConfScheme(), "D3-2修改评价主题-D2新增开通记录并授权(公共)-是否主配置方案不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexType(), "D3-2修改评价主题-D2新增开通记录并授权(公共)-开通对象类型编码不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexId(), "D3-2修改评价主题-D2新增开通记录并授权(公共)-开通对象ID不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getAuthorizationKeyTypeCode(), "D3-2修改评价主题-D2新增开通记录并授权(公共)-开通钥匙类型标识不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexName(), "D3-2修改评价主题-D2新增开通记录并授权(公共)-冗余开通对象名称不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getTenantSpaceId(), "D3-2修改评价主题-D2新增开通记录并授权(公共)-租户空间ID不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getSubjectLifeCycle(), "D3-2修改评价主题-D2新增开通记录并授权(公共)-主体生命周期不能为空", false);
                addOpenRecordAuthorizationComRespDto = fwCompSchemeOpenRecordClient.addOpenRecordAuthorizationCom(addOpenRecordAuthorizationComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
        }
        UpdateEvaThemeRespDto retData = new UpdateEvaThemeRespDto();


        return retData;
    }

    /**
     * D3-2批量查询评价模板[3074]
     * gen by moon at 11/9/2022, 1:00:53 AM
     */
    @Trace(operationName = "D3-2批量查询评价模板")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryEvaTempRespDto batchQueryEvaTemp(BatchQueryEvaTempReqDto reqDto) {


        List<OmsEvaluationTemplate> listOmsEvaluationTemplate_1 = new ArrayList<>();
//步骤0: 3-2-02批量查询评价模板 - batchQueryEvaTemp
        List<OmsEvaluationTemplate> listOmsEvaluationTemplate = new ArrayList<>();
        BatchQueryEvaTempReq batchQueryEvaTempReq = new BatchQueryEvaTempReq();
        if (reqDto != null) {
            batchQueryEvaTempReq.setEvalTempList(reqDto.getEvalTempList());//list-field-assign//sourceId:104157_1
            batchQueryEvaTempReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:258697_1
        }

        /*3-2-02批量查询评价模板[3075]   */

        listOmsEvaluationTemplate = mOmsEvaluationTemplateService.batchQueryEvaTemp(batchQueryEvaTempReq);


        listOmsEvaluationTemplate_1 = listOmsEvaluationTemplate;

        BatchQueryEvaTempRespDto retData = new BatchQueryEvaTempRespDto();
        retData.setEvalTempList(listOmsEvaluationTemplate_1.stream().map(item -> BeanUtil.toBean(item, EvalTempDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:104162_1


        return retData;
    }

    /**
     * D3-2查评价主题详情[2309]
     * gen by moon at 5/6/2023, 3:08:33 PM
     */
    @Trace(operationName = "D3-2查评价主题详情")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaThemeDetailRespDto queryEvaThemeDetail(QueryEvaThemeDetailReqDto reqDto) {


        OmsEvaluationSubject omsEvaluationSubject_1 = null;
        QueryConfResultNameUnconstrainedDetailComRespDto queryConfResultNameUnconstrainedDetailComRespDto_1 = null;
//步骤0: 3-2-01查评价主题详情 - queryEvaThemeDetail
        OmsEvaluationSubject omsEvaluationSubject = null;
        QueryEvaThemeDetailReq queryEvaThemeDetailReq = new QueryEvaThemeDetailReq();
        if (reqDto != null) {
            queryEvaThemeDetailReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:68180_1
        }

        /*3-2-01查评价主题详情[2310]   */
        Assert.isNull(queryEvaThemeDetailReq.getEvaluationSubjectId(), "D3-2查评价主题详情-3-2-01查评价主题详情-评价主题ID不能为空", false);
        omsEvaluationSubject = mOmsEvaluationSubjectService.queryEvaThemeDetail(queryEvaThemeDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaluationSubject_1 = omsEvaluationSubject;

//步骤1: D2查询配置答案名称等无约束(公共) - queryConfResultNameUnconstrainedDetailCom
        QueryConfResultNameUnconstrainedDetailComRespDto queryConfResultNameUnconstrainedDetailComRespDto = null;
        if (omsEvaluationSubject != null) {
            QueryConfResultNameUnconstrainedDetailComReqDto queryConfResultNameUnconstrainedDetailComReqDto = new QueryConfResultNameUnconstrainedDetailComReqDto();
            queryConfResultNameUnconstrainedDetailComReqDto.setIsPlatData("FALSE");//sourceId:896142_1
            if (omsEvaluationSubject != null) {
                queryConfResultNameUnconstrainedDetailComReqDto.setEndValue(omsEvaluationSubject.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:896139_1
                queryConfResultNameUnconstrainedDetailComReqDto.setConfSchemeId(omsEvaluationSubject.getConfSchemeId());//SimpleFieldAssign//sourceId:896141_1
            }
            if (reqDto != null) {
                queryConfResultNameUnconstrainedDetailComReqDto.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:896140_1
            }

            /*D2查评价主题类型名称[6483]   */
            Assert.isNull(queryConfResultNameUnconstrainedDetailComReqDto.getEndValue(), "D3-2查评价主题详情-D2查评价主题类型名称-答案值不能为空", false);
            Assert.isNull(queryConfResultNameUnconstrainedDetailComReqDto.getResultAspObjId(), "D3-2查评价主题详情-D2查评价主题类型名称-答案归属对象ID不能为空", false);
            Assert.isNull(queryConfResultNameUnconstrainedDetailComReqDto.getConfSchemeId(), "D3-2查评价主题详情-D2查评价主题类型名称-配置方案ID 不能为空", false);
            Assert.isNull(queryConfResultNameUnconstrainedDetailComReqDto.getIsPlatData(), "D3-2查评价主题详情-D2查评价主题类型名称-是否标准答案不能为空", false);
            queryConfResultNameUnconstrainedDetailComRespDto = confSchemeService.queryConfResultNameUnconstrainedDetailCom(queryConfResultNameUnconstrainedDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            queryConfResultNameUnconstrainedDetailComRespDto_1 = queryConfResultNameUnconstrainedDetailComRespDto;
        }

        QueryEvaThemeDetailRespDto retData = new QueryEvaThemeDetailRespDto();
        if (omsEvaluationSubject_1 != null) {
            retData.setEvaluationSubjectId(omsEvaluationSubject_1.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:67872_1
            retData.setEvaluationSubjectCode(omsEvaluationSubject_1.getEvaluationSubjectCode());//SimpleFieldAssign//sourceId:67873_1
            retData.setEvaluationSubjectName(omsEvaluationSubject_1.getEvaluationSubjectName());//SimpleFieldAssign//sourceId:67874_1
            retData.setEvaluationSubjectTypeCode(omsEvaluationSubject_1.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:104596_1
            retData.setBizSceneCode(omsEvaluationSubject_1.getBizSceneCode());//SimpleFieldAssign//sourceId:104597_1
            retData.setConfSchemeId(omsEvaluationSubject_1.getConfSchemeId());//SimpleFieldAssign//sourceId:896144_1
            retData.setConfSchemeCode(omsEvaluationSubject_1.getConfSchemeCode());//SimpleFieldAssign//sourceId:67875_1
            retData.setAscriptionSpaceId(omsEvaluationSubject_1.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:374833_1
            retData.setSubjectLifeCycle(omsEvaluationSubject_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:104598_1
            retData.setOperationInductionId(omsEvaluationSubject_1.getOperationInductionId());//SimpleFieldAssign//sourceId:104599_1
            retData.setOperateTime(omsEvaluationSubject_1.getOperateTime());//SimpleFieldAssign//sourceId:104600_1
        }
        if (queryConfResultNameUnconstrainedDetailComRespDto_1 != null) {
            retData.setEvaluationSubjectTypeName(queryConfResultNameUnconstrainedDetailComRespDto_1.getConfOptionName());//SimpleFieldAssign//sourceId:896143_1
        }


        return retData;
    }

    /**
     * D3-2查评价主题列表[2277]
     * gen by moon at 9/17/2022, 2:24:03 AM
     */
    @Trace(operationName = "D3-2查评价主题列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaThemeListRespDto queryEvaThemeList(QueryEvaThemeListReqDto reqDto) {


        List<OmsEvaluationSubject> listOmsEvaluationSubject_1 = new ArrayList<>();
//步骤0: 3-2-01查评价主题列表 - queryEvaThemeList
        List<OmsEvaluationSubject> listOmsEvaluationSubject = new ArrayList<>();
        QueryEvaThemeListReq queryEvaThemeListReq = new QueryEvaThemeListReq();
        if (reqDto != null) {
            queryEvaThemeListReq.setAscriptionSpaceId(reqDto.getAscriptionSpaceId());//sourceId:66800_1
            queryEvaThemeListReq.setBizSceneCode(reqDto.getBizSceneCode());//sourceId:67019_1
        }

        /*3-2-01查评价主题列表[2278]   */
        Assert.isNull(queryEvaThemeListReq.getAscriptionSpaceId(), "D3-2查评价主题列表-3-2-01查评价主题列表-归属空间ID不能为空", false);
        listOmsEvaluationSubject = mOmsEvaluationSubjectService.queryEvaThemeList(queryEvaThemeListReq);


        listOmsEvaluationSubject_1 = listOmsEvaluationSubject;

        QueryEvaThemeListRespDto retData = new QueryEvaThemeListRespDto();
        retData.setEvalThemeList(listOmsEvaluationSubject_1.stream().map(item -> BeanUtil.toBean(item, EvalThemeDto.class)).collect(Collectors.toList()));//sourceId:66804_1


        return retData;
    }

    /**
     * D3-2新增评价主题[2118]
     * gen by moon at 5/24/2023, 3:53:57 AM
     */
    @Trace(operationName = "D3-2新增评价主题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddEvaThemeRespDto addEvaTheme(AddEvaThemeReqDto reqDto) {


        String string_1 = null;
        AddOpenRecordAuthorizationComRespDto addOpenRecordAuthorizationComRespDto_1 = null;
        String string_3 = null;
//virtualUsage D2-3查询配置方案详情(公共)  40073
        QueryConfSchemeDetailComRespDto queryConfSchemeDetailComRespDto = null;
        QueryConfSchemeDetailComReqDto queryConfSchemeDetailComReqDto = new QueryConfSchemeDetailComReqDto();
        queryConfSchemeDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:897082_1_40073
        if (reqDto != null) {
            queryConfSchemeDetailComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:897063_1_40073
        }

        /*D2-3查询配置方案详情(公共)[1981]   */
        Assert.isNull(queryConfSchemeDetailComReqDto.getConfSchemeId(), "D3-2新增评价主题-D2-3查询配置方案详情(公共)-配置方案ID 不能为空", false);
        Assert.isNull(queryConfSchemeDetailComReqDto.getSubjectLifeCycle(), "D3-2新增评价主题-D2-3查询配置方案详情(公共)-生命周期状态不能为空", false);
        queryConfSchemeDetailComRespDto = confSchemeService.queryConfSchemeDetailCom(queryConfSchemeDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D2-3查询分组匹配结果转答案(公共)(跨服务）  19196
        QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
        QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto = new QueryClassMatchResultToAnswerDetailComReqDto();
        queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("THEME_BASIC_SET_CLASS");//CUSTOM_CONVENTION//sourceId:114491_1_19196
        queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:308501_1_19196
        if (reqDto != null) {
            queryClassMatchResultToAnswerDetailComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:894875_1_19196
        }

        /*D2-3查询分组匹配结果转答案(公共)(跨服务）[3088]   */
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfSchemeId(), "D3-2新增评价主题-D2-3查询分组匹配结果转答案(公共)(跨服务）-配置方案ID 不能为空", false);
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(), "D3-2新增评价主题-D2-3查询分组匹配结果转答案(公共)(跨服务）-分组标识不能为空", false);
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(), "D3-2新增评价主题-D2-3查询分组匹配结果转答案(公共)(跨服务）-是否标准答案不能为空", false);
        queryClassMatchResultToAnswerDetailComRespDto = confSchemeService.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D1-2查空间详情(公共)  19232
        QuerySpaceDetailComRespDto querySpaceDetailComRespDto = null;
        QuerySpaceDetailComReqDto querySpaceDetailComReqDto = new QuerySpaceDetailComReqDto();
        if (reqDto != null) {
            querySpaceDetailComReqDto.setSpaceId(reqDto.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:375016_1_19232
        }

        /*D1-2查空间详情(公共)[402]   */
        Assert.isNull(querySpaceDetailComReqDto.getSpaceId(), "D3-2新增评价主题-D1-2查空间详情(公共)-空间ID不能为空", false);
        querySpaceDetailComRespDto = baseService.querySpaceDetailCom(querySpaceDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage M3业务应用公共字段推送内存  19233
        //ModelCode: publicFieldCache
        ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
        if (querySpaceDetailComRespDto != null) {
            ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq = new ImplementBizPublicFieldPushMemoryReqDto();
            if (querySpaceDetailComRespDto != null) {
                publicFieldCacheReq.setSpaceId(querySpaceDetailComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:375014_1_19233
                publicFieldCacheReq.setAppId(querySpaceDetailComRespDto.getAppId());//SimpleFieldAssign//sourceId:375015_1_19233
            }

            /*M3业务应用公共字段推送内存[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
            Assert.isNull(publicFieldCacheReq.getSpaceId(), "D3-2新增评价主题-M3业务应用公共字段推送内存-创建于空间ID不能为空", false);
            Assert.isNull(publicFieldCacheReq.getAppId(), "D3-2新增评价主题-M3业务应用公共字段推送内存-创建于联盟应用ID不能为空", false);
            publicFieldCacheRes = nbEvaTheme.implementBizPublicFieldPushMemory(publicFieldCacheReq);


        }
//virtualUsage 3-2-02新增评价主题  19197
        String string = null;
        if (queryClassMatchResultToAnswerDetailComRespDto != null && queryConfSchemeDetailComRespDto != null) {
            OmsEvaluationSubject omsEvaluationSubject = new OmsEvaluationSubject();
            if (reqDto != null) {
                omsEvaluationSubject.setEvaluationSubjectName(reqDto.getEvaluationSubjectName());//SimpleFieldAssign//sourceId:61437_1_19197
                omsEvaluationSubject.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:114621_1_19197
                omsEvaluationSubject.setAscriptionSpaceId(reqDto.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:61690_1_19197
                omsEvaluationSubject.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:61441_1_19197
            }
            if (queryClassMatchResultToAnswerDetailComRespDto != null) {
                omsEvaluationSubject.setEvaluationSubjectTypeCode(queryClassMatchResultToAnswerDetailComRespDto.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:66920_1_19197
                omsEvaluationSubject.setBizSceneCode(queryClassMatchResultToAnswerDetailComRespDto.getBizSceneCode());//SimpleFieldAssign//sourceId:114619_1_19197
            }
            if (queryConfSchemeDetailComRespDto != null) {
                omsEvaluationSubject.setConfSchemeCode(queryConfSchemeDetailComRespDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:66921_1_19197
            }

            /*3-2-02新增评价主题[2117]   */
            Assert.isNull(omsEvaluationSubject.getEvaluationSubjectName(), "D3-2新增评价主题-3-2-02新增评价主题-评价主题名称不能为空", false);
            Assert.isNull(omsEvaluationSubject.getEvaluationSubjectTypeCode(), "D3-2新增评价主题-3-2-02新增评价主题-评价主题类型编码 不能为空", false);
            Assert.isNull(omsEvaluationSubject.getBizSceneCode(), "D3-2新增评价主题-3-2-02新增评价主题-冗余业务场景标识不能为空", false);
            Assert.isNull(omsEvaluationSubject.getConfSchemeId(), "D3-2新增评价主题-3-2-02新增评价主题-冗余配置方案ID 不能为空", false);
            Assert.isNull(omsEvaluationSubject.getConfSchemeCode(), "D3-2新增评价主题-3-2-02新增评价主题-冗余配置方案标识不能为空", false);
            Assert.isNull(omsEvaluationSubject.getAscriptionSpaceId(), "D3-2新增评价主题-3-2-02新增评价主题-归属空间ID不能为空", false);
            Assert.isNull(omsEvaluationSubject.getSubjectLifeCycle(), "D3-2新增评价主题-3-2-02新增评价主题-主体生命周期不能为空", false);
            string = mOmsEvaluationSubjectService.addEvaTheme(omsEvaluationSubject)/*vcase invoke 本地 method 方法调用;*/;


            string_1 = string;
        }
        if ((reqDto != null && reqDto.getSubjectLifeCycle() != null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))) {
            //if(D3-2新增评价主题.主体生命周期 等于 当前有效)  40203

            AddOpenRecordAuthorizationComRespDto addOpenRecordAuthorizationComRespDto = null;
            if (queryConfSchemeDetailComRespDto != null && queryClassMatchResultToAnswerDetailComRespDto != null && string != null) {
                AddOpenRecordAuthorizationComReqDto addOpenRecordAuthorizationComReqDto = new AddOpenRecordAuthorizationComReqDto();
                addOpenRecordAuthorizationComReqDto.setApplexType("EVA_THEME");//sourceId:894278_1_40204
                if (reqDto != null) {
                    addOpenRecordAuthorizationComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:894270_1_40204
                    addOpenRecordAuthorizationComReqDto.setAuthType(reqDto.getAuthType());//SimpleFieldAssign//sourceId:894272_1_40204
                    addOpenRecordAuthorizationComReqDto.setAuthorizationNum(reqDto.getRemainingQty());//SimpleFieldAssign//sourceId:894273_1_40204
                    addOpenRecordAuthorizationComReqDto.setAuthUnit(reqDto.getAuthUnit());//SimpleFieldAssign//sourceId:894274_1_40204
                    addOpenRecordAuthorizationComReqDto.setStartTime(reqDto.getStartTime());//SimpleFieldAssign//sourceId:894275_1_40204
                    addOpenRecordAuthorizationComReqDto.setEndTime(reqDto.getEndTime());//SimpleFieldAssign//sourceId:894276_1_40204
                    addOpenRecordAuthorizationComReqDto.setIsMainConfScheme(reqDto.getIsMainConfScheme());//SimpleFieldAssign//sourceId:894277_1_40204
                    addOpenRecordAuthorizationComReqDto.setApplexName(reqDto.getEvaluationSubjectName());//SimpleFieldAssign//sourceId:915056_1_40204
                    addOpenRecordAuthorizationComReqDto.setTenantSpaceId(reqDto.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:894280_1_40204
                    addOpenRecordAuthorizationComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:894281_1_40204
                }
                if (queryConfSchemeDetailComRespDto != null) {
                    addOpenRecordAuthorizationComReqDto.setConfSchemeCode(queryConfSchemeDetailComRespDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:894271_1_40204
                }
                if (queryClassMatchResultToAnswerDetailComRespDto != null) {
                    addOpenRecordAuthorizationComReqDto.setAuthorizationKeyTypeCode(queryClassMatchResultToAnswerDetailComRespDto.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:932181_1_40204
                }
                if (string != null) {
                    addOpenRecordAuthorizationComReqDto.setApplexId(string);//SimpleFieldAssign//sourceId:894279_1_40204
                }

                /*D2新增开通记录并授权(公共)[3102]   */
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getConfSchemeId(), "D3-2新增评价主题-D2新增开通记录并授权(公共)-配置方案ID 不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getConfSchemeCode(), "D3-2新增评价主题-D2新增开通记录并授权(公共)-配置方案标识不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getIsMainConfScheme(), "D3-2新增评价主题-D2新增开通记录并授权(公共)-是否主配置方案不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexType(), "D3-2新增评价主题-D2新增开通记录并授权(公共)-开通对象类型编码不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getAuthorizationKeyTypeCode(), "D3-2新增评价主题-D2新增开通记录并授权(公共)-开通钥匙类型标识不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexId(), "D3-2新增评价主题-D2新增开通记录并授权(公共)-开通对象ID不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexName(), "D3-2新增评价主题-D2新增开通记录并授权(公共)-冗余开通对象名称不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getTenantSpaceId(), "D3-2新增评价主题-D2新增开通记录并授权(公共)-租户空间ID不能为空", false);
                Assert.isNull(addOpenRecordAuthorizationComReqDto.getSubjectLifeCycle(), "D3-2新增评价主题-D2新增开通记录并授权(公共)-主体生命周期不能为空", false);
                addOpenRecordAuthorizationComRespDto = fwCompSchemeOpenRecordClient.addOpenRecordAuthorizationCom(addOpenRecordAuthorizationComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                addOpenRecordAuthorizationComRespDto_1 = addOpenRecordAuthorizationComRespDto;
            }
        }
//virtualUsage 3-11-04新增评价主题当前步骤  19942
        String string_2 = null;
        if (string != null) {
            OmsBasicInstanceAssistBehaviorCurrentStep omsBasicInstanceAssistBehaviorCurrentStep = new OmsBasicInstanceAssistBehaviorCurrentStep();
            omsBasicInstanceAssistBehaviorCurrentStep.setStepObj("OMS_EVALUATION_SUBJECT");//sourceId:388578_1_19942
            omsBasicInstanceAssistBehaviorCurrentStep.setStepNameCode("PLAN_DATA");//CUSTOM_CONVENTION//sourceId:388577_1_19942
            omsBasicInstanceAssistBehaviorCurrentStep.setThemeContentTypeCode("OMS_FRAMEWORK_SPACE");//sourceId:865993_1_19942
            if (string != null) {
                omsBasicInstanceAssistBehaviorCurrentStep.setEntityId(string);//SimpleFieldAssign//sourceId:388579_1_19942
            }
            if (reqDto != null) {
                omsBasicInstanceAssistBehaviorCurrentStep.setThemeContentId(reqDto.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:865994_1_19942
            }

            /*3-11-04新增评价主题当前步骤[2427]   */
            Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getEntityId(), "D3-2新增评价主题-3-11-04新增评价主题当前步骤-步骤内容实例ID不能为空", false);
            Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getStepObj(), "D3-2新增评价主题-3-11-04新增评价主题当前步骤-步骤使用对象表不能为空", false);
            Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getStepNameCode(), "D3-2新增评价主题-3-11-04新增评价主题当前步骤-步骤编码不能为空", false);
            Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getThemeContentTypeCode(), "D3-2新增评价主题-3-11-04新增评价主题当前步骤-主题内容类型编码不能为空", false);
            Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getThemeContentId(), "D3-2新增评价主题-3-11-04新增评价主题当前步骤-主题内容ID不能为空", false);
            string_2 = mOmsBasicInstanceAssistBehaviorCurrentStepService.addBizAppServiceContCurrentBstep(omsBasicInstanceAssistBehaviorCurrentStep)/*vcase invoke 本地 method 方法调用;*/;


            string_3 = string_2;
        }
        AddEvaThemeRespDto retData = new AddEvaThemeRespDto();
        if (string_1 != null) {
            retData.setEvaluationSubjectId(string_1);//SimpleFieldAssign//sourceId:61449_1
        }
        if (addOpenRecordAuthorizationComRespDto_1 != null) {
            retData.setSchOpenRecordId(addOpenRecordAuthorizationComRespDto_1.getSchOpenRecordId());//SimpleFieldAssign//sourceId:895242_1
            retData.setApplexRelId(addOpenRecordAuthorizationComRespDto_1.getApplexRelId());//SimpleFieldAssign//sourceId:895239_1
        }
        if (string_3 != null) {
            retData.setBehaviorCurrentStepId(string_3);//SimpleFieldAssign//sourceId:895241_1
        }


        return retData;
    }

    /**
     * D3-2删除评价主题[3162]
     * gen by moon at 9/20/2022, 6:33:17 PM
     */
    @Trace(operationName = "D3-2删除评价主题")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteEvaThemeRespDto deleteEvaTheme(DeleteEvaThemeReqDto reqDto) {


        OmsEvaluationSubject omsEvaluationSubject_1 = null;
//步骤0: 3-2-01查评价主题详情 - queryEvaThemeDetail
        OmsEvaluationSubject omsEvaluationSubject = null;
        QueryEvaThemeDetailReq queryEvaThemeDetailReq = new QueryEvaThemeDetailReq();
        queryEvaThemeDetailReq.setSubjectLifeCycle("EDITING");//sourceId:244991_1
        if (reqDto != null) {
            queryEvaThemeDetailReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//sourceId:244997_1
        }

        /*3-2-01查评价主题详情[2310]   */
        Assert.isNull(queryEvaThemeDetailReq.getEvaluationSubjectId(), "D3-2删除评价主题-3-2-01查评价主题详情-评价主题ID不能为空", false);
        Assert.isNull(queryEvaThemeDetailReq.getSubjectLifeCycle(), "D3-2删除评价主题-3-2-01查评价主题详情-主体生命周期不能为空", false);
        omsEvaluationSubject = mOmsEvaluationSubjectService.queryEvaThemeDetail(queryEvaThemeDetailReq);
        Assert.isTrue(omsEvaluationSubject == null || omsEvaluationSubject.getEvaluationSubjectId() == null, "返回值不能为空", false);

        omsEvaluationSubject_1 = omsEvaluationSubject;

//步骤1: 3-2-01删除评价主题 - deleteEvaTheme
        boolean bOOLEAN;
        String string = new String();
        if (reqDto != null) {
            string = reqDto.getEvaluationSubjectId();
            ;//sourceId:114748_1
        }

        /*3-2-01删除评价主题[3163]   */
        Assert.isNull(string, "D3-2删除评价主题-3-2-01删除评价主题-评价主题ID不能为空", false);
        bOOLEAN = mOmsEvaluationSubjectService.deleteEvaTheme(string);


//步骤2: D3-12删除内容当前行为步骤(公共) - deleteContCurrentBstepCom
        DeleteContCurrentBstepComRespDto deleteContCurrentBstepComRespDto = null;
        DeleteContCurrentBstepComReqDto deleteContCurrentBstepComReqDto = new DeleteContCurrentBstepComReqDto();
        deleteContCurrentBstepComReqDto.setStepObj("OMS_EVALUATION_SUBJECT");//sourceId:336178_1
        if (reqDto != null) {
            deleteContCurrentBstepComReqDto.setEntityId(reqDto.getEvaluationSubjectId());//sourceId:336177_1
        }

        /*D3-12删除内容当前行为步骤(公共)[4623]   */
        Assert.isNull(deleteContCurrentBstepComReqDto.getEntityId(), "D3-2删除评价主题-D3-12删除内容当前行为步骤(公共)-步骤内容实例ID不能为空", false);
        Assert.isNull(deleteContCurrentBstepComReqDto.getStepObj(), "D3-2删除评价主题-D3-12删除内容当前行为步骤(公共)-步骤使用对象表不能为空", false);
        deleteContCurrentBstepComRespDto = offStateService.deleteContCurrentBstepCom(deleteContCurrentBstepComReqDto);


        DeleteEvaThemeRespDto retData = new DeleteEvaThemeRespDto();
        if (omsEvaluationSubject_1 != null) {
            retData.setConfSchemeCode(omsEvaluationSubject_1.getConfSchemeCode());//sourceId:332306_1
            retData.setAscriptionSpaceId(omsEvaluationSubject_1.getAscriptionSpaceId());//sourceId:332304_1
        }


        return retData;
    }

    /**
     * D3-2查评价模板详情[3062]
     * gen by moon at 5/9/2023, 5:37:35 AM
     */
    @Trace(operationName = "D3-2查评价模板详情")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaTempDetailRespDto queryEvaTempDetail(QueryEvaTempDetailReqDto reqDto) {


        OmsEvaluationTemplate omsEvaluationTemplate_1 = null;
        OmsTarget omsTarget_1 = null;
//步骤0: 3-2-02查评价模板详情 - queryEvaTempDetail
        OmsEvaluationTemplate omsEvaluationTemplate = null;
        QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
        if (reqDto != null) {
            queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:102129_1
            queryEvaTempDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:102135_1
            queryEvaTempDetailReq.setArchivngType(reqDto.getArchivngType());//SimpleFieldAssign//sourceId:160599_1
        }

        /*3-2-02查评价模板详情[2316]   */
        Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(), "D3-2查评价模板详情-3-2-02查评价模板详情-评价模板ID不能为空", false);
        omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;
        Assert.isTrue(omsEvaluationTemplate == null || omsEvaluationTemplate.getEvaluationTemplateId() == null, "找不到数据，系统异常", false);

        omsEvaluationTemplate_1 = omsEvaluationTemplate;

//步骤1: 3-3-01查目标详情 - queryTargetDetail
        OmsTarget omsTarget = null;
        if (omsEvaluationTemplate != null) {
            QueryTargetDetailReq queryTargetDetailReq = new QueryTargetDetailReq();
            if (omsEvaluationTemplate != null) {
                queryTargetDetailReq.setTargetId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:216230_1
            }
            if (reqDto != null) {
                queryTargetDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:216224_1
            }

            /*3-3-01查目标详情[2488]   */
            Assert.isNull(queryTargetDetailReq.getTargetId(), "D3-2查评价模板详情-3-3-01查目标详情-目标ID不能为空", false);
            omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;
            Assert.isTrue(omsTarget == null || omsTarget.getTargetId() == null, "找不到数据，系统异常", false);

            omsTarget_1 = omsTarget;
        }

        QueryEvaTempDetailRespDto retData = new QueryEvaTempDetailRespDto();
        if (omsEvaluationTemplate_1 != null) {
            retData.setEvaluationTemplateId(omsEvaluationTemplate_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:102162_1
            retData.setEvaluationTemplateCode(omsEvaluationTemplate_1.getEvaluationTemplateCode());//SimpleFieldAssign//sourceId:102163_1
            retData.setEvaluationTempNumber(omsEvaluationTemplate_1.getEvaluationTempNumber());//SimpleFieldAssign//sourceId:114939_1
            retData.setEvaluationTempName(omsEvaluationTemplate_1.getEvaluationTempName());//SimpleFieldAssign//sourceId:102165_1
            retData.setEvaluationTempShortName(omsEvaluationTemplate_1.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:102164_1
            retData.setDeptId(omsEvaluationTemplate_1.getDeptId());//SimpleFieldAssign//sourceId:102168_1
            retData.setEvaluationSubjectId(omsEvaluationTemplate_1.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:102166_1
            retData.setTargetId(omsEvaluationTemplate_1.getTargetId());//SimpleFieldAssign//sourceId:102167_1
            retData.setIsOpenBudget(omsEvaluationTemplate_1.getIsOpenBudget());//SimpleFieldAssign//sourceId:102170_1
            retData.setIsOpenBudgetReport(omsEvaluationTemplate_1.getIsOpenBudgetReport());//SimpleFieldAssign//sourceId:102171_1
            retData.setConfSchemeId(omsEvaluationTemplate_1.getConfSchemeId());//SimpleFieldAssign//sourceId:907878_1
            retData.setConfSchemeCode(omsEvaluationTemplate_1.getConfSchemeCode());//SimpleFieldAssign//sourceId:102169_1
            retData.setEvaluationTemplateTypeCode(omsEvaluationTemplate_1.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:102172_1
            retData.setTargetPlanTempSubtype(omsEvaluationTemplate_1.getTargetPlanTempSubtype());//SimpleFieldAssign//sourceId:102173_1
            retData.setIsOkrPlanScene(omsEvaluationTemplate_1.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:102174_1
            retData.setEvaluationSubjectTypeCode(omsEvaluationTemplate_1.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:102175_1
            retData.setBizSceneCode(omsEvaluationTemplate_1.getBizSceneCode());//SimpleFieldAssign//sourceId:102176_1
            retData.setPlanningType(omsEvaluationTemplate_1.getPlanningType());//SimpleFieldAssign//sourceId:102177_1
            retData.setBatchCode(omsEvaluationTemplate_1.getBatchCode());//SimpleFieldAssign//sourceId:102178_1
            retData.setCreateTime(omsEvaluationTemplate_1.getCreateTime());//SimpleFieldAssign//sourceId:114940_1
        }
        if (omsTarget_1 != null) {
            retData.setTargetCode(omsTarget_1.getTargetCode());//SimpleFieldAssign//sourceId:216242_1
            retData.setPeriodicModeTypeCode(omsTarget_1.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:216234_1
        }


        return retData;
    }

    /**
     * D3-2批量增评价角色(公共)[3216]
     * gen by moon at 10/9/2022, 11:44:26 PM
     */
    @Trace(operationName = "D3-2批量增评价角色(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchAddFillRoleComRespDto batchAddFillRoleCom(BatchAddFillRoleComReqDto reqDto) {


        //步骤0: D2-3查配置项匹配答案列表(公共)（跨服务） - queryConfItemMatchAnswerListCom
        QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto = null;
        QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto = new QueryConfItemMatchAnswerListComReqDto();
        queryConfItemMatchAnswerListComReqDto.setConfItemCode("TEMP_AUDIT_EVA_SET");//CUSTOM_CONVENTION//sourceId:361541_1
        queryConfItemMatchAnswerListComReqDto.setIsPlatData("TRUE");//sourceId:361544_1
        if (reqDto != null) {
            queryConfItemMatchAnswerListComReqDto.setConfSchemeCode(reqDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:361540_1
        }

        /*D2-3查询模板配置评价角色结果列表(公共)[2505]   */
        Assert.isNull(queryConfItemMatchAnswerListComReqDto.getConfSchemeCode(), "D3-2批量增评价角色(公共)-D2-3查询模板配置评价角色结果列表(公共)-配置方案标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerListComReqDto.getConfItemCode(), "D3-2批量增评价角色(公共)-D2-3查询模板配置评价角色结果列表(公共)-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerListComReqDto.getIsPlatData(), "D3-2批量增评价角色(公共)-D2-3查询模板配置评价角色结果列表(公共)-是否平台数据不能为空", false);
        queryConfItemMatchAnswerListComRespDto = confSchemeService.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto).getData();


//步骤1: D1-2查询角色列表ByCodes(公共) - batchQueryRoleListByCodesCom
        BatchQueryRoleListByCodesComRespDto batchQueryRoleListByCodesComRespDto = null;
        if (queryConfItemMatchAnswerListComRespDto != null) {
            BatchQueryRoleListByCodesComReqDto batchQueryRoleListByCodesComReqDto = new BatchQueryRoleListByCodesComReqDto();
            batchQueryRoleListByCodesComReqDto.setRoleType("BUSINESS_ROLE");//sourceId:315167_1
            if (queryConfItemMatchAnswerListComRespDto != null) {
                batchQueryRoleListByCodesComReqDto.setRoleCodeList(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList().stream().map(item -> item.getEndValue())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:121910_1
            }

            /*D1-2查询角色列表ByCodes(公共)[3223]   */
            Assert.isNull(batchQueryRoleListByCodesComReqDto.getRoleType(), "D3-2批量增评价角色(公共)-D1-2查询角色列表ByCodes(公共)-角色类型不能为空", false);
            batchQueryRoleListByCodesComRespDto = fwBaseRoleClient.batchQueryRoleListByCodesCom(batchQueryRoleListByCodesComReqDto).getData();
            Assert.isTrue(batchQueryRoleListByCodesComRespDto == null || batchQueryRoleListByCodesComRespDto.getRoleList() == null || !CollectionUtil.isEmpty(batchQueryRoleListByCodesComRespDto.getRoleList()) || batchQueryRoleListByCodesComRespDto.getRoleList().size() == 0, "返回值不能为空", false);


        }

//步骤2: M3生成角色数据集聚合(特殊方法） - generateCollectionsAggregation
        //ModelCode: collectionsMergeData
        GenerateCollectionsAggregationRespDto collectionsMergeDataRes = null;
        if (queryConfItemMatchAnswerListComRespDto != null) {
            GenerateCollectionsAggregationReqDto collectionsMergeDataReq = new GenerateCollectionsAggregationReqDto();
            if (queryConfItemMatchAnswerListComRespDto != null && queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList() != null && !CollectionUtil.isEmpty(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList())) {
                collectionsMergeDataReq.setConfSchemeItemResultList(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList().stream().map(item -> {
                    ConfSchemeItemResultDto elm = BeanUtil.toBean(item, ConfSchemeItemResultDto.class);
                    //elm.setEndValue();//UNION_ID  TODO ruizhe dong

                    return elm;
                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:327681_1
            }
            if (batchQueryRoleListByCodesComRespDto != null && batchQueryRoleListByCodesComRespDto.getRoleList() != null && !CollectionUtil.isEmpty(batchQueryRoleListByCodesComRespDto.getRoleList())) {
                collectionsMergeDataReq.setRoleList(batchQueryRoleListByCodesComRespDto.getRoleList().stream().map(item -> {
                    FrameworkSceneRoleDto elm = BeanUtil.toBean(item, FrameworkSceneRoleDto.class);
                    //elm.setRoleCode();//UNION_ID  TODO ruizhe dong

                    return elm;
                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:327682_1
            }

            /*M3生成角色数据集聚合(特殊方法）[4558]  入参多个数据集，取并集 */

            collectionsMergeDataRes = nbEvaTheme.generateCollectionsAggregation(collectionsMergeDataReq);


        }

//步骤3: 3-2-06批量增评价填报角色 - batchAddEvaFillRole
        boolean bOOLEAN;
        List<OmsEvaluationFillRole> listOmsEvaluationFillRole = new ArrayList<>();
        if (collectionsMergeDataRes != null && collectionsMergeDataRes.getRoleList() != null && !CollectionUtil.isEmpty(collectionsMergeDataRes.getRoleList())) {
            listOmsEvaluationFillRole = //objList-to-objLists
                    collectionsMergeDataRes.getRoleList().stream().map(item -> {
                        OmsEvaluationFillRole elm = new OmsEvaluationFillRole();
                        elm.setRoleTypeCode("APPLICANT");//sourceId:63164_2
                        elm.setIsSystemType("TRUE");//sourceId:63167_2
                        if (item != null) {
                            elm.setRoleId(item.getRoleId());//SimpleFieldAssign//sourceId:63172_2
                            elm.setRoleCode(item.getRoleCode());//SimpleFieldAssign//sourceId:63163_2
                            elm.setRoleName(item.getRoleName());//SimpleFieldAssign//sourceId:63173_2
                            elm.setOrderNumber(item.getNumber() != null ? Long.valueOf(item.getNumber()) : null);//SimpleFieldAssign//sourceId:63168_2
                        }
                        if (reqDto != null) {
                            elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:63165_2
                            elm.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:63169_2
                        }
                        return elm;
                    }).collect(Collectors.toList());//objList-to-objLists//sourceId:121697_1
        }

        /*3-2-06批量增评价填报角色[3217]   */

        bOOLEAN = mOmsEvaluationFillRoleService.batchAddEvaFillRole(listOmsEvaluationFillRole);


        BatchAddFillRoleComRespDto retData = new BatchAddFillRoleComRespDto();


        return retData;
    }

    /**
     * D3-2新增评价模板[3100]
     * gen by moon at 7/1/2024, 6:32:23 PM
     */
    @Trace(operationName = "D3-2新增评价模板")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddEvaTempRespDto addEvaTemp(AddEvaTempReqDto reqDto) {


        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 = null;
        String string_1 = null;
        String string_3 = null;
        OmsBizAppBatch omsBizAppBatch_2 = null;
        String string_5 = null;
//步骤0: M3-获取接收字段（特殊方法） - obtainReceiveField
        //ModelCode: receptionService
        ObtainReceiveFieldRespDto receptionServiceRes = null;
        ObtainReceiveFieldReqDto receptionServiceReq = new ObtainReceiveFieldReqDto();


        /*M3-接收入参字段[2451]  用于特殊方法接收上游入参。 */

        receptionServiceRes = nbEvaTheme.obtainReceiveField(receptionServiceReq);


//步骤1: D3-3判断新增的评价模板(公共) - judgeAddEvaTempCom
        JudgeAddEvaTempComRespDto judgeAddEvaTempComRespDto = null;
        JudgeAddEvaTempComReqDto judgeAddEvaTempComReqDto = new JudgeAddEvaTempComReqDto();
        if (reqDto != null) {
            judgeAddEvaTempComReqDto.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:872605_1
        }

        /*D3-3判断新增的评价模板(公共)[4760]   */
        Assert.isNull(judgeAddEvaTempComReqDto.getEvaluationSubjectId(), "D3-2新增评价模板-D3-3判断新增的评价模板(公共)-评价主题ID不能为空", false);
        judgeAddEvaTempComRespDto = judgeAddEvaTempCom(judgeAddEvaTempComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤2: D2-3查询配置方案详情(公共) - queryConfSchemeDetailCom
        QueryConfSchemeDetailComRespDto queryConfSchemeDetailComRespDto = null;
        QueryConfSchemeDetailComReqDto queryConfSchemeDetailComReqDto = new QueryConfSchemeDetailComReqDto();
        if (reqDto != null) {
            queryConfSchemeDetailComReqDto.setConfSchemeCode(reqDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:335460_1
        }

        /*D2-3查询配置方案详情(公共)[1981]   */
        Assert.isNull(queryConfSchemeDetailComReqDto.getConfSchemeCode(), "D3-2新增评价模板-D2-3查询配置方案详情(公共)-配置方案标识不能为空", false);
        queryConfSchemeDetailComRespDto = confSchemeService.queryConfSchemeDetailCom(queryConfSchemeDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤3: D2-3查询方案匹配单一结果转答案(公共)（跨服务） - querySchemeMatchSingleResultToAnswerDetailCom
        QuerySchemeMatchSingleResultToAnswerDetailComRespDto querySchemeMatchSingleResultToAnswerDetailComRespDto = null;
        if (queryConfSchemeDetailComRespDto != null) {
            QuerySchemeMatchSingleResultToAnswerDetailComReqDto querySchemeMatchSingleResultToAnswerDetailComReqDto = new QuerySchemeMatchSingleResultToAnswerDetailComReqDto();
            querySchemeMatchSingleResultToAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:308586_1
            if (reqDto != null) {
                querySchemeMatchSingleResultToAnswerDetailComReqDto.setConfSchemeCode(reqDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:108675_1
            }
            if (queryConfSchemeDetailComRespDto != null) {
                querySchemeMatchSingleResultToAnswerDetailComReqDto.setIsInitialScheme(queryConfSchemeDetailComRespDto.getIsInitialScheme());//SimpleFieldAssign//sourceId:108678_1
            }

            /*D2-3查询模板配置答案（跨服务）[3101]   */
            Assert.isNull(querySchemeMatchSingleResultToAnswerDetailComReqDto.getConfSchemeCode(), "D3-2新增评价模板-D2-3查询模板配置答案（跨服务）-配置方案标识不能为空", false);
            Assert.isNull(querySchemeMatchSingleResultToAnswerDetailComReqDto.getIsInitialScheme(), "D3-2新增评价模板-D2-3查询模板配置答案（跨服务）-是否初始方案答案不能为空", false);
            Assert.isNull(querySchemeMatchSingleResultToAnswerDetailComReqDto.getIsPlatData(), "D3-2新增评价模板-D2-3查询模板配置答案（跨服务）-是否标准答案不能为空", false);
            querySchemeMatchSingleResultToAnswerDetailComRespDto = confSchemeService.querySchemeMatchSingleResultToAnswerDetailCom(querySchemeMatchSingleResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
            Assert.isTrue(querySchemeMatchSingleResultToAnswerDetailComRespDto == null || querySchemeMatchSingleResultToAnswerDetailComRespDto.getConfSchemeId() == null, "找不到数据，系统异常", false);


        }

//步骤4: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        if (queryConfSchemeDetailComRespDto != null) {
            QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
            queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("IS_OPEN_CUSTOM_REPORT");//CUSTOM_CONVENTION//sourceId:939122_1
            queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:939131_1
            if (queryConfSchemeDetailComRespDto != null) {
                queryConfItemMatchAnswerDetailComReqDto.setConfSchemeId(queryConfSchemeDetailComRespDto.getConfSchemeId());//SimpleFieldAssign//sourceId:939133_1
            }

            /*D2-3查是否开启自定义汇报答案[2486]   */
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfSchemeId(), "D3-2新增评价模板-D2-3查是否开启自定义汇报答案-配置方案ID 不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3-2新增评价模板-D2-3查是否开启自定义汇报答案-配置项标识不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3-2新增评价模板-D2-3查是否开启自定义汇报答案-是否标准答案不能为空", false);
            queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;
        }

//步骤5: D2-3查询分组匹配结果转答案(公共)(跨服务） - queryClassMatchResultToAnswerDetailCom
        QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
        QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto = new QueryClassMatchResultToAnswerDetailComReqDto();
        queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("FINANCE_GROUP");//CUSTOM_CONVENTION//sourceId:1531598_1
        queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1531599_1
        queryClassMatchResultToAnswerDetailComReqDto.setIsSingleResult("TRUE");//sourceId:1531600_1
        if (reqDto != null) {
            queryClassMatchResultToAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1531597_1
        }

        /*D2查评价主题预算分组单选配置答案(是否开启预算、是否开启预算汇报）[3088]   */
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getResultAspObjId(), "D3-2新增评价模板-D2查评价主题预算分组单选配置答案(是否开启预算、是否开启预算汇报）-开通对象ID不能为空", false);
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(), "D3-2新增评价模板-D2查评价主题预算分组单选配置答案(是否开启预算、是否开启预算汇报）-分组标识不能为空", false);
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(), "D3-2新增评价模板-D2查评价主题预算分组单选配置答案(是否开启预算、是否开启预算汇报）-是否标准答案不能为空", false);
        Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsSingleResult(), "D3-2新增评价模板-D2查评价主题预算分组单选配置答案(是否开启预算、是否开启预算汇报）-是否单一答案不能为空", false);
        queryClassMatchResultToAnswerDetailComRespDto = confSchemeService.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤6: 3-2-02新增评价模板 - addEvaTemp
        String string = null;
        if (queryClassMatchResultToAnswerDetailComRespDto != null) {
            OmsEvaluationTemplate omsEvaluationTemplate = new OmsEvaluationTemplate();
            if (reqDto != null) {
                omsEvaluationTemplate.setEvaluationTempNumber(reqDto.getEvaluationTempNumber());//SimpleFieldAssign//sourceId:106543_1
                omsEvaluationTemplate.setEvaluationTempName(reqDto.getEvaluationTempName());//SimpleFieldAssign//sourceId:106544_1
                omsEvaluationTemplate.setEvaluationTempShortName(reqDto.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:106545_1
                omsEvaluationTemplate.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:106547_1
                omsEvaluationTemplate.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:106548_1
                omsEvaluationTemplate.setConfSchemeCode(reqDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:106556_1
            }
            if (queryClassMatchResultToAnswerDetailComRespDto != null) {
                omsEvaluationTemplate.setIsOpenBudget(queryClassMatchResultToAnswerDetailComRespDto.getIsOpenBudget());//SimpleFieldAssign//sourceId:172535_1
                omsEvaluationTemplate.setIsOpenBudgetReport(queryClassMatchResultToAnswerDetailComRespDto.getIsOpenBudgetReport());//SimpleFieldAssign//sourceId:172536_1
            }
            if (querySchemeMatchSingleResultToAnswerDetailComRespDto != null) {
                omsEvaluationTemplate.setPlanningType(querySchemeMatchSingleResultToAnswerDetailComRespDto.getPlanningType());//SimpleFieldAssign//sourceId:106553_1
                omsEvaluationTemplate.setEvaluationTemplateTypeCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:106549_1
                omsEvaluationTemplate.setTargetPlanTempSubtype(querySchemeMatchSingleResultToAnswerDetailComRespDto.getTargetPlanTempSubtype());//SimpleFieldAssign//sourceId:106555_1
                omsEvaluationTemplate.setIsOkrPlanScene(querySchemeMatchSingleResultToAnswerDetailComRespDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:106550_1
                omsEvaluationTemplate.setEvaluationSubjectTypeCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:106551_1
                omsEvaluationTemplate.setBizSceneCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getBizSceneCode());//SimpleFieldAssign//sourceId:106552_1
            }
            if (queryConfSchemeDetailComRespDto != null) {
                omsEvaluationTemplate.setConfSchemeId(queryConfSchemeDetailComRespDto.getConfSchemeId());//SimpleFieldAssign//sourceId:907076_1
            }

            /*3-2-02新增评价模板[2344]   */
            Assert.isNull(omsEvaluationTemplate.getEvaluationTempNumber(), "D3-2新增评价模板-3-2-02新增评价模板-评价模板编号不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getEvaluationTempName(), "D3-2新增评价模板-3-2-02新增评价模板-评价模板名称不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getEvaluationTempShortName(), "D3-2新增评价模板-3-2-02新增评价模板-评价模板简称不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getEvaluationSubjectId(), "D3-2新增评价模板-3-2-02新增评价模板-归属评价主题ID不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getIsOpenBudget(), "D3-2新增评价模板-3-2-02新增评价模板-是否开启预算不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getIsOpenBudgetReport(), "D3-2新增评价模板-3-2-02新增评价模板-是否开启预算汇报不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getPlanningType(), "D3-2新增评价模板-3-2-02新增评价模板-规划类型不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getEvaluationTemplateTypeCode(), "D3-2新增评价模板-3-2-02新增评价模板-冗余评价模板类型配置项不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getTargetPlanTempSubtype(), "D3-2新增评价模板-3-2-02新增评价模板-冗余目标规划模板子类型不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getIsOkrPlanScene(), "D3-2新增评价模板-3-2-02新增评价模板-冗余开启OKR场景配置项不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getEvaluationSubjectTypeCode(), "D3-2新增评价模板-3-2-02新增评价模板-冗余评价主题类型配置项不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getBizSceneCode(), "D3-2新增评价模板-3-2-02新增评价模板-冗余业务场景标识配置项不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getConfSchemeId(), "D3-2新增评价模板-3-2-02新增评价模板-冗余配置方案ID 不能为空", false);
            Assert.isNull(omsEvaluationTemplate.getConfSchemeCode(), "D3-2新增评价模板-3-2-02新增评价模板-冗余配置方案标识不能为空", false);
            string = mOmsEvaluationTemplateService.addEvaTemp(omsEvaluationTemplate)/*vcase invoke 本地 method 方法调用;*/;


            string_1 = string;
        }

//步骤7: D3执行评价模板批次相关设置初始化(公共) - implementEvaTempBatchSetInitializeCom
        ImplementEvaTempBatchSetInitializeComRespDto implementEvaTempBatchSetInitializeComRespDto = null;
        if (queryConfSchemeDetailComRespDto != null) {
            ImplementEvaTempBatchSetInitializeComReqDto implementEvaTempBatchSetInitializeComReqDto = new ImplementEvaTempBatchSetInitializeComReqDto();
            if (queryConfSchemeDetailComRespDto != null) {
                implementEvaTempBatchSetInitializeComReqDto.setConfSchemeId(queryConfSchemeDetailComRespDto.getConfSchemeId());//SimpleFieldAssign//sourceId:834290_1
            }
            if (string != null) {
                implementEvaTempBatchSetInitializeComReqDto.setEvaluationTemplateId(string);//SimpleFieldAssign//sourceId:834291_1
            }

            /*D3执行评价模板批次相关设置初始化(公共)[6299]   */
            Assert.isNull(implementEvaTempBatchSetInitializeComReqDto.getConfSchemeId(), "D3-2新增评价模板-D3执行评价模板批次相关设置初始化(公共)-配置方案ID 不能为空", false);
            Assert.isNull(implementEvaTempBatchSetInitializeComReqDto.getEvaluationTemplateId(), "D3-2新增评价模板-D3执行评价模板批次相关设置初始化(公共)-冗余评价模板ID不能为空", false);
            implementEvaTempBatchSetInitializeComRespDto = batchService.implementEvaTempBatchSetInitializeCom(implementEvaTempBatchSetInitializeComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤8: M3-生成语义内容 - generateSemanticContent
        //ModelCode: generateSemanticInstance
        GenerateEvaTempBatchNameRespDto generateSemanticInstanceRes = null;
        GenerateEvaTempBatchNameReqDto generateSemanticInstanceReq = new GenerateEvaTempBatchNameReqDto();
        generateSemanticInstanceReq.setSystemDateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:108819_1
        generateSemanticInstanceReq.setRandomNumberDigits(Long.valueOf(6));//CUSTOM_CONVENTION//sourceId:108820_1
        if (reqDto != null) {
            generateSemanticInstanceReq.setTargetContentName(reqDto.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:336642_1
        }

        /*M生成评价模板批次名称[2391]  解析语义模板，生成模板实例 */
        Assert.isNull(generateSemanticInstanceReq.getSystemDateTime(), "D3-2新增评价模板-M生成评价模板批次名称-系统当前时间不能为空", false);
        Assert.isNull(generateSemanticInstanceReq.getRandomNumberDigits(), "D3-2新增评价模板-M生成评价模板批次名称-随机数位数不能为空", false);
        Assert.isNull(generateSemanticInstanceReq.getTargetContentName(), "D3-2新增评价模板-M生成评价模板批次名称-目标内容名称不能为空", false);
        generateSemanticInstanceRes = nbEvaTheme.generateEvaTempBatchName(generateSemanticInstanceReq);


//步骤9: 3-13-01新增业务应用批次 - addBizAppBatch
        String string_2 = null;
        if (string != null) {
            OmsBizAppBatch omsBizAppBatch = new OmsBizAppBatch();
            omsBizAppBatch.setPurposeTypeCode("TOP_EVA_TEMP_MGT");//sourceId:106560_1
            omsBizAppBatch.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:106564_1
            omsBizAppBatch.setIsFirst("TRUE");//sourceId:106562_1
            omsBizAppBatch.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:865987_1
            if (generateSemanticInstanceRes != null) {
                omsBizAppBatch.setBatchName(generateSemanticInstanceRes.getObjectName());//SimpleFieldAssign//sourceId:106559_1
            }
            if (string != null) {
                omsBizAppBatch.setAscriptionObjectId(string);//SimpleFieldAssign//sourceId:106561_1
                omsBizAppBatch.setThemeContentId(string);//SimpleFieldAssign//sourceId:865988_1
            }

            /*3-13-01新增业务应用批次[2348]   */
            Assert.isNull(omsBizAppBatch.getBatchName(), "D3-2新增评价模板-3-13-01新增业务应用批次-批次名称不能为空", false);
            Assert.isNull(omsBizAppBatch.getAscriptionObjectId(), "D3-2新增评价模板-3-13-01新增业务应用批次-归属对象ID不能为空", false);
            Assert.isNull(omsBizAppBatch.getPurposeTypeCode(), "D3-2新增评价模板-3-13-01新增业务应用批次-用途类型编码不能为空", false);
            Assert.isNull(omsBizAppBatch.getBatchEndTime(), "D3-2新增评价模板-3-13-01新增业务应用批次-批次结束时间不能为空", false);
            Assert.isNull(omsBizAppBatch.getIsFirst(), "D3-2新增评价模板-3-13-01新增业务应用批次-是否首次批次不能为空", false);
            Assert.isNull(omsBizAppBatch.getThemeContentTypeCode(), "D3-2新增评价模板-3-13-01新增业务应用批次-主题内容类型编码不能为空", false);
            Assert.isNull(omsBizAppBatch.getThemeContentId(), "D3-2新增评价模板-3-13-01新增业务应用批次-主题内容ID不能为空", false);
            string_2 = mOmsBizAppBatchService.addBizAppBatch(omsBizAppBatch)/*vcase invoke 本地 method 方法调用;*/;


            string_3 = string_2;
        }

//步骤10: 3-13-01查业务应用批次详情 - queryBizAppBatchDetail
        OmsBizAppBatch omsBizAppBatch_1 = null;
        if (string_2 != null) {
            QueryBizAppBatchDetailReq queryBizAppBatchDetailReq = new QueryBizAppBatchDetailReq();
            queryBizAppBatchDetailReq.setPurposeTypeCode("TOP_EVA_TEMP_MGT");//sourceId:322710_1
            queryBizAppBatchDetailReq.setIsNewbatch("TRUE");//sourceId:322714_1
            if (string_2 != null) {
                queryBizAppBatchDetailReq.setBatchId(string_2);//SimpleFieldAssign//sourceId:322717_1
            }
            if (string != null) {
                queryBizAppBatchDetailReq.setAscriptionObjectId(string);//SimpleFieldAssign//sourceId:322711_1
            }

            /*3-13-01查业务应用批次详情[2668]   */
            Assert.isNull(queryBizAppBatchDetailReq.getBatchId(), "D3-2新增评价模板-3-13-01查业务应用批次详情-批次ID不能为空", false);
            Assert.isNull(queryBizAppBatchDetailReq.getPurposeTypeCode(), "D3-2新增评价模板-3-13-01查业务应用批次详情-用途类型编码不能为空", false);
            Assert.isNull(queryBizAppBatchDetailReq.getAscriptionObjectId(), "D3-2新增评价模板-3-13-01查业务应用批次详情-归属对象ID不能为空", false);
            Assert.isNull(queryBizAppBatchDetailReq.getIsNewbatch(), "D3-2新增评价模板-3-13-01查业务应用批次详情-是否最新批次不能为空", false);
            omsBizAppBatch_1 = mOmsBizAppBatchService.queryBizAppBatchDetail(queryBizAppBatchDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            omsBizAppBatch_2 = omsBizAppBatch_1;
        }

//步骤11: 3-3-01新增目标 - addTarget
        String string_4 = null;
        if (querySchemeMatchSingleResultToAnswerDetailComRespDto != null) {
            OmsTarget omsTarget = new OmsTarget();
            omsTarget.setTargetCode("1001");//CUSTOM_CONVENTION//sourceId:106599_1
            omsTarget.setIsOpenCustomReport("FALSE");//sourceId:974702_1
            omsTarget.setDataInitStatus("FALSE");//sourceId:335454_1
            omsTarget.setTargetPgsStatus("NOT_AT_THE");//sourceId:315080_1
            if (querySchemeMatchSingleResultToAnswerDetailComRespDto != null) {
                omsTarget.setPeriodicModeTypeCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:106600_1
                omsTarget.setBizSceneCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getBizSceneCode());//SimpleFieldAssign//sourceId:335455_1
                omsTarget.setEvaluationSubjectTypeCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:335456_1
                omsTarget.setEvaluationTemplateTypeCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:335457_1
                omsTarget.setPlanningType(querySchemeMatchSingleResultToAnswerDetailComRespDto.getPlanningType());//SimpleFieldAssign//sourceId:335458_1
            }
            if (string != null) {
                omsTarget.setEvaluationTemplateId(string);//SimpleFieldAssign//sourceId:106601_1
            }
            if (reqDto != null) {
                omsTarget.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:106602_1
            }
            if (omsBizAppBatch_1 != null) {
                omsTarget.setBatchCode(omsBizAppBatch_1.getBatchCode());//SimpleFieldAssign//sourceId:106603_1
            }

            /*3-3-01新增目标[2345]   */
            Assert.isNull(omsTarget.getTargetCode(), "D3-2新增评价模板-3-3-01新增目标-目标标识不能为空", false);
            Assert.isNull(omsTarget.getPeriodicModeTypeCode(), "D3-2新增评价模板-3-3-01新增目标-周期模式类型编码不能为空", false);
            Assert.isNull(omsTarget.getEvaluationTemplateId(), "D3-2新增评价模板-3-3-01新增目标-归属评价模板ID不能为空", false);
            Assert.isNull(omsTarget.getEvaluationSubjectId(), "D3-2新增评价模板-3-3-01新增目标-冗余评价主题ID不能为空", false);
            Assert.isNull(omsTarget.getIsOpenCustomReport(), "D3-2新增评价模板-3-3-01新增目标-是否开启自定义汇报不能为空", false);
            Assert.isNull(omsTarget.getDataInitStatus(), "D3-2新增评价模板-3-3-01新增目标-数据初始化完成状态不能为空", false);
            Assert.isNull(omsTarget.getBizSceneCode(), "D3-2新增评价模板-3-3-01新增目标-冗余业务场景标识配置项不能为空", false);
            Assert.isNull(omsTarget.getEvaluationSubjectTypeCode(), "D3-2新增评价模板-3-3-01新增目标-冗余评价主题类型配置项不能为空", false);
            Assert.isNull(omsTarget.getEvaluationTemplateTypeCode(), "D3-2新增评价模板-3-3-01新增目标-冗余评价模板类型配置项不能为空", false);
            Assert.isNull(omsTarget.getPlanningType(), "D3-2新增评价模板-3-3-01新增目标-冗余规划类型不能为空", false);
            Assert.isNull(omsTarget.getTargetPgsStatus(), "D3-2新增评价模板-3-3-01新增目标-目标进展状态不能为空", false);
            Assert.isNull(omsTarget.getBatchCode(), "D3-2新增评价模板-3-3-01新增目标-批次标识不能为空", false);
            string_4 = mOmsTargetService.addTarget(omsTarget)/*vcase invoke 本地 method 方法调用;*/;


            string_5 = string_4;
        }

//步骤12: 3-2-02修改评价模板 - updateEvaTemp
        boolean bOOLEAN;
        if (string != null) {
            OmsEvaluationTemplate omsEvaluationTemplate_1 = new OmsEvaluationTemplate();
            if (string != null) {
                omsEvaluationTemplate_1.setEvaluationTemplateId(string);//SimpleFieldAssign//sourceId:106605_1
            }
            if (string_4 != null) {
                omsEvaluationTemplate_1.setTargetId(string_4);//SimpleFieldAssign//sourceId:106607_1
            }
            if (omsBizAppBatch_1 != null) {
                omsEvaluationTemplate_1.setBatchCode(omsBizAppBatch_1.getBatchCode());//SimpleFieldAssign//sourceId:106606_1
            }

            /*3-2-02修改评价模板[2393]   */
            Assert.isNull(omsEvaluationTemplate_1.getEvaluationTemplateId(), "D3-2新增评价模板-3-2-02修改评价模板-评价模板ID不能为空", false);
            Assert.isNull(omsEvaluationTemplate_1.getTargetId(), "D3-2新增评价模板-3-2-02修改评价模板-对应的目标ID不能为空", false);
            Assert.isNull(omsEvaluationTemplate_1.getBatchCode(), "D3-2新增评价模板-3-2-02修改评价模板-批次标识不能为空", false);
            bOOLEAN = mOmsEvaluationTemplateService.updateEvaTemp(omsEvaluationTemplate_1)/*vcase invoke 本地 method 方法调用;*/;


        }

//步骤13: D3-5新增规划资料(公共) - addPlanDataCom
        AddPlanDataComRespDto addPlanDataComRespDto = null;
        if (querySchemeMatchSingleResultToAnswerDetailComRespDto != null) {
            AddPlanDataComReqDto addPlanDataComReqDto = new AddPlanDataComReqDto();
            addPlanDataComReqDto.setIsMainplan("TRUE");//sourceId:1914397_1
            addPlanDataComReqDto.setPlanSchemeClass("MASTER_PLAN");//sourceId:1914400_1
            if (reqDto != null) {
                addPlanDataComReqDto.setPlanningNumber(reqDto.getEvaluationTempNumber());//SimpleFieldAssign//sourceId:1914394_1
                addPlanDataComReqDto.setPlanningName(reqDto.getEvaluationTempName());//SimpleFieldAssign//sourceId:1914395_1
                addPlanDataComReqDto.setPlanningShortName(reqDto.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:1914396_1
                addPlanDataComReqDto.setHypertextContent(reqDto.getHypertextContent());//SimpleFieldAssign//sourceId:222453_1
                addPlanDataComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1914405_1
            }
            if (querySchemeMatchSingleResultToAnswerDetailComRespDto != null) {
                addPlanDataComReqDto.setOkrType(querySchemeMatchSingleResultToAnswerDetailComRespDto.getOkrType());//SimpleFieldAssign//sourceId:1914398_1
                addPlanDataComReqDto.setPlanningType(querySchemeMatchSingleResultToAnswerDetailComRespDto.getPlanningType());//SimpleFieldAssign//sourceId:1914399_1
            }
            if (string != null) {
                addPlanDataComReqDto.setEvaObjTargetCycleId(string);//SimpleFieldAssign//sourceId:1914407_1
                addPlanDataComReqDto.setEvaluationTemplateId(string);//SimpleFieldAssign//sourceId:1914403_1
            }
            if (omsBizAppBatch_1 != null) {
                addPlanDataComReqDto.setBatchCode(omsBizAppBatch_1.getBatchCode());//SimpleFieldAssign//sourceId:1914404_1
            }

            /*D3-5新增规划资料(公共)[3137]   */
            Assert.isNull(addPlanDataComReqDto.getPlanningNumber(), "D3-2新增评价模板-D3-5新增规划资料(公共)-规划编号不能为空", false);
            Assert.isNull(addPlanDataComReqDto.getPlanningName(), "D3-2新增评价模板-D3-5新增规划资料(公共)-规划名称不能为空", false);
            Assert.isNull(addPlanDataComReqDto.getPlanningShortName(), "D3-2新增评价模板-D3-5新增规划资料(公共)-规划简称不能为空", false);
            Assert.isNull(addPlanDataComReqDto.getHypertextContent(), "D3-2新增评价模板-D3-5新增规划资料(公共)-超文本内容不能为空", false);
            Assert.isNull(addPlanDataComReqDto.getIsMainplan(), "D3-2新增评价模板-D3-5新增规划资料(公共)-是否总规划不能为空", false);
            Assert.isNull(addPlanDataComReqDto.getOkrType(), "D3-2新增评价模板-D3-5新增规划资料(公共)-OKR类型不能为空", false);
            Assert.isNull(addPlanDataComReqDto.getPlanningType(), "D3-2新增评价模板-D3-5新增规划资料(公共)-规划类型不能为空", false);
            Assert.isNull(addPlanDataComReqDto.getPlanSchemeClass(), "D3-2新增评价模板-D3-5新增规划资料(公共)-规划方案类别不能为空", false);
            Assert.isNull(addPlanDataComReqDto.getEvaObjTargetCycleId(), "D3-2新增评价模板-D3-5新增规划资料(公共)-被评对象目标周期ID不能为空", false);
            Assert.isNull(addPlanDataComReqDto.getEvaluationTemplateId(), "D3-2新增评价模板-D3-5新增规划资料(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(addPlanDataComReqDto.getBatchCode(), "D3-2新增评价模板-D3-5新增规划资料(公共)-批次标识不能为空", false);
            addPlanDataComRespDto = planDataService.addPlanDataCom(addPlanDataComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤14: D3新增定时任务调度(公共) - addTimerTaskPlanCom
        AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto = null;
        if (string_4 != null) {
            AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto = new AddTimerTaskPlanComReqDto();
            addTimerTaskPlanComReqDto.setIsCompensateTask("FALSE");//sourceId:389199_1
            addTimerTaskPlanComReqDto.setDispatchActionTypeCode("STAGE_CURRENT_CYCLE_ETC");//sourceId:389200_1
            addTimerTaskPlanComReqDto.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:389201_1
            addTimerTaskPlanComReqDto.setObjectTypeCode("OMS_TARGET");//sourceId:389202_1
            addTimerTaskPlanComReqDto.setStandbyField1("1001");//CUSTOM_CONVENTION//sourceId:389216_1
            addTimerTaskPlanComReqDto.setAddRuleInfoTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:389205_1
            addTimerTaskPlanComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:540769_1
            addTimerTaskPlanComReqDto.setIsAppointSimpleMq("FALSE");//sourceId:972433_1
            addTimerTaskPlanComReqDto.setIsComplete("FALSE");//sourceId:389214_1
            addTimerTaskPlanComReqDto.setIsRealTimeaSync("FALSE");//sourceId:731006_1
            addTimerTaskPlanComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:389211_1
            addTimerTaskPlanComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:389212_1
            addTimerTaskPlanComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:389213_1
            if (reqDto != null) {
                addTimerTaskPlanComReqDto.setTargetContentName(reqDto.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:389198_1
            }
            if (string_4 != null) {
                addTimerTaskPlanComReqDto.setObjectId(string_4);//SimpleFieldAssign//sourceId:389203_1
            }
            if (string != null) {
                addTimerTaskPlanComReqDto.setAddRuleInfoId(string);//SimpleFieldAssign//sourceId:389206_1
                addTimerTaskPlanComReqDto.setThemeContentId(string);//SimpleFieldAssign//sourceId:540770_1
            }

            /*D3-2新增更新执行周期阶段当前周期等任务[4995]   */
            Assert.isNull(addTimerTaskPlanComReqDto.getTargetContentName(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-目标内容名称不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getIsCompensateTask(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-是否补偿任务不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getDispatchActionTypeCode(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-任务调度的行为类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getTaskDispatchTypeCode(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-任务调度类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getStandbyField1(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-备用字段1不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoTypeCode(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-生成规则信息类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoId(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-生成辅助规则信息值不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentTypeCode(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-主题内容类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentId(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-主题内容ID不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getIsComplete(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-是否执行完成不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getOperationInductionId(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-操作人就职记录ID不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getSpaceId(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-创建于空间ID不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getAppId(), "D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-创建于联盟应用ID不能为空", false);
            addTimerTaskPlanComRespDto = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤15: 3-11-04新增业务应用内容当前行为步骤 - addBizAppServiceContCurrentBstep
        String string_6 = null;
        if (string != null) {
            OmsBasicInstanceAssistBehaviorCurrentStep omsBasicInstanceAssistBehaviorCurrentStep = new OmsBasicInstanceAssistBehaviorCurrentStep();
            omsBasicInstanceAssistBehaviorCurrentStep.setStepObj("OMS_EVALUATION_TEMPLATE");//sourceId:387990_1
            omsBasicInstanceAssistBehaviorCurrentStep.setStepNameCode("COMPILE_TARGET_TASK");//CUSTOM_CONVENTION//sourceId:387989_1
            omsBasicInstanceAssistBehaviorCurrentStep.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:867474_1
            if (string != null) {
                omsBasicInstanceAssistBehaviorCurrentStep.setEntityId(string);//SimpleFieldAssign//sourceId:387991_1
                omsBasicInstanceAssistBehaviorCurrentStep.setThemeContentId(string);//SimpleFieldAssign//sourceId:867475_1
            }

            /*3-11-04新增评价模板当前行为步骤[2427]   */
            Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getEntityId(), "D3-2新增评价模板-3-11-04新增评价模板当前行为步骤-步骤内容实例ID不能为空", false);
            Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getStepObj(), "D3-2新增评价模板-3-11-04新增评价模板当前行为步骤-步骤使用对象表不能为空", false);
            Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getStepNameCode(), "D3-2新增评价模板-3-11-04新增评价模板当前行为步骤-步骤编码不能为空", false);
            Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getThemeContentTypeCode(), "D3-2新增评价模板-3-11-04新增评价模板当前行为步骤-主题内容类型编码不能为空", false);
            Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getThemeContentId(), "D3-2新增评价模板-3-11-04新增评价模板当前行为步骤-主题内容ID不能为空", false);
            string_6 = mOmsBasicInstanceAssistBehaviorCurrentStepService.addBizAppServiceContCurrentBstep(omsBasicInstanceAssistBehaviorCurrentStep)/*vcase invoke 本地 method 方法调用;*/;


        }

//步骤16: D3-更新业务服务内容当前步骤(公共) - refreshBizAppServiceContCurrentBstepCom
        RefreshBizAppServiceContCurrentBstepComRespDto refreshBizAppServiceContCurrentBstepComRespDto = null;
        RefreshBizAppServiceContCurrentBstepComReqDto refreshBizAppServiceContCurrentBstepComReqDto = new RefreshBizAppServiceContCurrentBstepComReqDto();
        refreshBizAppServiceContCurrentBstepComReqDto.setStepObj("OMS_EVALUATION_SUBJECT");//sourceId:334722_1
        refreshBizAppServiceContCurrentBstepComReqDto.setBizSceneCode("ADD_EVA_TEMP");//CUSTOM_CONVENTION//sourceId:334720_1
        refreshBizAppServiceContCurrentBstepComReqDto.setOrderNumber(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:334719_1
        if (reqDto != null) {
            refreshBizAppServiceContCurrentBstepComReqDto.setEntityId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:334718_1
        }

        /*D3-更新评价主题当前步骤(第2步)[4593]   */
        Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getEntityId(), "D3-2新增评价模板-D3-更新评价主题当前步骤(第2步)-步骤内容实例ID不能为空", false);
        Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getStepObj(), "D3-2新增评价模板-D3-更新评价主题当前步骤(第2步)-步骤使用对象表不能为空", false);
        Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getBizSceneCode(), "D3-2新增评价模板-D3-更新评价主题当前步骤(第2步)-业务场景标识不能为空", false);
        Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getOrderNumber(), "D3-2新增评价模板-D3-更新评价主题当前步骤(第2步)-排序不能为空", false);
        refreshBizAppServiceContCurrentBstepComRespDto = offStateService.refreshBizAppServiceContCurrentBstepCom(refreshBizAppServiceContCurrentBstepComReqDto)/*vcase invoke isSameApp*/;


        AddEvaTempRespDto retData = new AddEvaTempRespDto();
        if (string_1 != null) {
            retData.setEvaluationTemplateId(string_1);//SimpleFieldAssign//sourceId:108822_1
        }
        if (string_3 != null) {
            retData.setBatchId(string_3);//SimpleFieldAssign//sourceId:322702_1
        }
        if (omsBizAppBatch_2 != null) {
            retData.setBatchCode(omsBizAppBatch_2.getBatchCode());//SimpleFieldAssign//sourceId:322815_1
        }
        if (string_5 != null) {
            retData.setTargetId(string_5);//SimpleFieldAssign//sourceId:108824_1
        }
        if (queryConfItemMatchAnswerDetailComRespDto_1 != null) {
            retData.setEndValue(queryConfItemMatchAnswerDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:939291_1
        }


        return retData;
    }

    /**
     * D3-2新增评价画像相关[3112]
     * gen by moon at 2/26/2024, 3:29:13 AM
     */
    @Trace(operationName = "D3-2新增评价画像相关")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddEvaPortraitRelatedRespDto addEvaPortraitRelated(AddEvaPortraitRelatedReqDto reqDto) {


        String string_1 = null;
        String string_3 = null;
        AddEvaFillRoleComRespDto addEvaFillRoleComRespDto_1 = null;
        String string_5 = null;
        String string_7 = null;
        String string_9 = null;
//步骤0: 3-2-02查评价模板详情 - queryEvaTempDetail
        OmsEvaluationTemplate omsEvaluationTemplate = null;
        QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
        queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:108655_1
        if (reqDto != null) {
            queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:108649_1
        }

        /*3-2-02查评价模板[2316]   */
        Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(), "D3-2新增评价画像相关-3-2-02查评价模板-评价模板ID不能为空", false);
        Assert.isNull(queryEvaTempDetailReq.getIsArchive(), "D3-2新增评价画像相关-3-2-02查评价模板-是否存档不能为空", false);
        omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        if (omsEvaluationTemplate != null) {
            QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
            queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("EVA_THEME_HOST_TYPE_CODE");//CUSTOM_CONVENTION//sourceId:374285_1
            queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:374294_1
            if (omsEvaluationTemplate != null) {
                queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:374287_1
            }

            /*D2-3查画像宿主类型标识答案（评价主题）[2486]   */
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D3-2新增评价画像相关-D2-3查画像宿主类型标识答案（评价主题）-开通对象ID不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3-2新增评价画像相关-D2-3查画像宿主类型标识答案（评价主题）-配置项标识不能为空", false);
            Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3-2新增评价画像相关-D2-3查画像宿主类型标识答案（评价主题）-是否标准答案不能为空", false);
            queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }

//步骤2: 3-2-04新增评价画像 - addEvaPortrait
        String string = null;
        if (queryConfItemMatchAnswerDetailComRespDto != null) {
            OmsEvaluationPortrait omsEvaluationPortrait = new OmsEvaluationPortrait();
            omsEvaluationPortrait.setParentChildTemplate("FALSE");//sourceId:374280_1
            omsEvaluationPortrait.setIsSystemType("TRUE");//sourceId:374281_1
            omsEvaluationPortrait.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:374282_1
            if (queryConfItemMatchAnswerDetailComRespDto != null) {
                omsEvaluationPortrait.setHostTypeCode(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:374278_1
            }
            if (reqDto != null) {
                omsEvaluationPortrait.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:374279_1
            }
            if (omsEvaluationTemplate != null) {
                omsEvaluationPortrait.setEvaluationSubjectId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:637749_1
                omsEvaluationPortrait.setEvaluationObjectInputValue(omsEvaluationTemplate.getSpaceId());//SimpleFieldAssign//sourceId:374299_1
                omsEvaluationPortrait.setBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:374283_1
            }

            /*3-2-04新增评价画像[2349]   */
            Assert.isNull(omsEvaluationPortrait.getHostTypeCode(), "D3-2新增评价画像相关-3-2-04新增评价画像-评价画像宿主类型标识不能为空", false);
            Assert.isNull(omsEvaluationPortrait.getEvaluationTemplateId(), "D3-2新增评价画像相关-3-2-04新增评价画像-评价模板ID不能为空", false);
            Assert.isNull(omsEvaluationPortrait.getEvaluationSubjectId(), "D3-2新增评价画像相关-3-2-04新增评价画像-冗余评价主题ID不能为空", false);
            Assert.isNull(omsEvaluationPortrait.getParentChildTemplate(), "D3-2新增评价画像相关-3-2-04新增评价画像-是否支持父子模板不能为空", false);
            Assert.isNull(omsEvaluationPortrait.getIsSystemType(), "D3-2新增评价画像相关-3-2-04新增评价画像-是否系统类型不能为空", false);
            Assert.isNull(omsEvaluationPortrait.getEvaluationObjectInputValue(), "D3-2新增评价画像相关-3-2-04新增评价画像-查询虚拟宿主的实例条件不能为空", false);
            Assert.isNull(omsEvaluationPortrait.getOrderNumber(), "D3-2新增评价画像相关-3-2-04新增评价画像-排序不能为空", false);
            Assert.isNull(omsEvaluationPortrait.getBatchCode(), "D3-2新增评价画像相关-3-2-04新增评价画像-批次标识不能为空", false);
            string = mOmsEvaluationPortraitService.addEvaPortrait(omsEvaluationPortrait)/*vcase invoke 本地 method 方法调用;*/;


            string_1 = string;
        }

//步骤3: 3-2-05新增评价对象 - addEvaObject
        String string_2 = null;
        if (string != null) {
            OmsEvaluationObject omsEvaluationObject = new OmsEvaluationObject();
            omsEvaluationObject.setTableTypeCode("OMS_FRAMEWORK_SPACE");//sourceId:107255_1
            omsEvaluationObject.setEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:107256_1
            omsEvaluationObject.setIsAutoSystem("TRUE");//sourceId:107254_1
            omsEvaluationObject.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:107257_1
            if (string != null) {
                omsEvaluationObject.setEvaluationPortraitId(string);//SimpleFieldAssign//sourceId:374296_1
            }
            if (reqDto != null) {
                omsEvaluationObject.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:158730_1
            }
            if (omsEvaluationTemplate != null) {
                omsEvaluationObject.setEvaluationSubjectId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:637751_1
                omsEvaluationObject.setBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:107258_1
            }

            /*3-2-05新增评价对象[2350]   */
            Assert.isNull(omsEvaluationObject.getEvaluationPortraitId(), "D3-2新增评价画像相关-3-2-05新增评价对象-评价画像ID不能为空", false);
            Assert.isNull(omsEvaluationObject.getTableTypeCode(), "D3-2新增评价画像相关-3-2-05新增评价对象-内容表类型编码不能为空", false);
            Assert.isNull(omsEvaluationObject.getEntityId(), "D3-2新增评价画像相关-3-2-05新增评价对象-内容表主键ID不能为空", false);
            Assert.isNull(omsEvaluationObject.getIsAutoSystem(), "D3-2新增评价画像相关-3-2-05新增评价对象-是否系统自动数据不能为空", false);
            Assert.isNull(omsEvaluationObject.getEvaluationTemplateId(), "D3-2新增评价画像相关-3-2-05新增评价对象-评价模板ID不能为空", false);
            Assert.isNull(omsEvaluationObject.getEvaluationSubjectId(), "D3-2新增评价画像相关-3-2-05新增评价对象-冗余评价主题ID不能为空", false);
            Assert.isNull(omsEvaluationObject.getOrderNumber(), "D3-2新增评价画像相关-3-2-05新增评价对象-排序不能为空", false);
            Assert.isNull(omsEvaluationObject.getBatchCode(), "D3-2新增评价画像相关-3-2-05新增评价对象-批次标识不能为空", false);
            string_2 = mOmsEvaluationObjectService.addEvaObject(omsEvaluationObject)/*vcase invoke 本地 method 方法调用;*/;


            string_3 = string_2;
        }

//步骤4: D3-2新增评价填报角色(公共) - addEvaFillRoleCom
        AddEvaFillRoleComRespDto addEvaFillRoleComRespDto = null;
        if (omsEvaluationTemplate != null) {
            AddEvaFillRoleComReqDto addEvaFillRoleComReqDto = new AddEvaFillRoleComReqDto();
            if (omsEvaluationTemplate != null) {
                addEvaFillRoleComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:952861_1
                addEvaFillRoleComReqDto.setEvaluationSubjectId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:637757_1
                addEvaFillRoleComReqDto.setBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:376034_1
            }
            if (reqDto != null) {
                addEvaFillRoleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:376033_1
            }

            /*D3-2新增评价填报角色(公共)[4830]   */
            Assert.isNull(addEvaFillRoleComReqDto.getConfSchemeId(), "D3-2新增评价画像相关-D3-2新增评价填报角色(公共)-配置方案ID 不能为空", false);
            Assert.isNull(addEvaFillRoleComReqDto.getEvaluationTemplateId(), "D3-2新增评价画像相关-D3-2新增评价填报角色(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(addEvaFillRoleComReqDto.getEvaluationSubjectId(), "D3-2新增评价画像相关-D3-2新增评价填报角色(公共)-冗余评价主题ID不能为空", false);
            Assert.isNull(addEvaFillRoleComReqDto.getBatchCode(), "D3-2新增评价画像相关-D3-2新增评价填报角色(公共)-批次标识不能为空", false);
            addEvaFillRoleComRespDto = addEvaFillRoleCom(addEvaFillRoleComReqDto)/*vcase invoke 同服务,同domain*/;


            addEvaFillRoleComRespDto_1 = addEvaFillRoleComRespDto;
        }

//步骤5: 3-6-01新增虚拟组织 - addVirtualOrg
        String string_4 = null;
        if (omsEvaluationTemplate != null) {
            OmsVirtualOrg omsVirtualOrg = new OmsVirtualOrg();
            omsVirtualOrg.setTableTypeCode("OMS_TARGET");//sourceId:107279_1
            omsVirtualOrg.setEvaluationTemplateType("EVA_TEMP");//sourceId:177124_1
            omsVirtualOrg.setUseScene("TARGET_PLAN_SCENE");//sourceId:1559824_1
            omsVirtualOrg.setSubjectLifeCycle("EDITING");//sourceId:315168_1
            if (omsEvaluationTemplate != null) {
                omsVirtualOrg.setEntityId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:107280_1
                omsVirtualOrg.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:158728_1
                omsVirtualOrg.setBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:107281_1
                omsVirtualOrg.setCreateBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:1559825_1
            }

            /*3-6-03新增规划组[2352]   */
            Assert.isNull(omsVirtualOrg.getEntityId(), "D3-2新增评价画像相关-3-6-03新增规划组-内容表主键ID不能为空", false);
            Assert.isNull(omsVirtualOrg.getTableTypeCode(), "D3-2新增评价画像相关-3-6-03新增规划组-内容表类型编码不能为空", false);
            Assert.isNull(omsVirtualOrg.getEvaluationTemplateId(), "D3-2新增评价画像相关-3-6-03新增规划组-归属对象ID不能为空", false);
            Assert.isNull(omsVirtualOrg.getEvaluationTemplateType(), "D3-2新增评价画像相关-3-6-03新增规划组-归属对象类型不能为空", false);
            Assert.isNull(omsVirtualOrg.getBatchCode(), "D3-2新增评价画像相关-3-6-03新增规划组-批次标识不能为空", false);
            Assert.isNull(omsVirtualOrg.getCreateBatchCode(), "D3-2新增评价画像相关-3-6-03新增规划组-创建于批次标识不能为空", false);
            Assert.isNull(omsVirtualOrg.getUseScene(), "D3-2新增评价画像相关-3-6-03新增规划组-虚拟组织使用场景不能为空", false);
            Assert.isNull(omsVirtualOrg.getSubjectLifeCycle(), "D3-2新增评价画像相关-3-6-03新增规划组-主体生命周期不能为空", false);
            string_4 = mOmsVirtualOrgService.addVirtualOrg(omsVirtualOrg)/*vcase invoke 本地 method 方法调用;*/;


            string_5 = string_4;
        }

//步骤6: D3分析规划工作组开始时间(公共) - implementWorkGroupStartTimeCom
        ImplementWorkGroupStartTimeComRespDto implementWorkGroupStartTimeComRespDto = null;
        if (omsEvaluationTemplate != null) {
            ImplementWorkGroupStartTimeComReqDto implementWorkGroupStartTimeComReqDto = new ImplementWorkGroupStartTimeComReqDto();
            if (reqDto != null) {
                implementWorkGroupStartTimeComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1026853_1
            }
            if (omsEvaluationTemplate != null) {
                implementWorkGroupStartTimeComReqDto.setCreateTime(omsEvaluationTemplate.getCreateTime());//SimpleFieldAssign//sourceId:1026860_1
            }

            /*D3分析规划工作组开始时间(公共)[7166]   */
            Assert.isNull(implementWorkGroupStartTimeComReqDto.getCycleStartTime(), "D3-2新增评价画像相关-D3分析规划工作组开始时间(公共)-目标计划开始时间不能为空", false);
            Assert.isNull(implementWorkGroupStartTimeComReqDto.getCreateTime(), "D3-2新增评价画像相关-D3分析规划工作组开始时间(公共)-创建时间不能为空", false);
            implementWorkGroupStartTimeComRespDto = virtualOrgService.implementWorkGroupStartTimeCom(implementWorkGroupStartTimeComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤7: 3-6-03新增虚拟成员部门 - addVirtualOrgMemberDept
        String string_6 = null;
        if (string_4 != null) {
            OmsVirtualOrgMemberDept omsVirtualOrgMemberDept = new OmsVirtualOrgMemberDept();
            omsVirtualOrgMemberDept.setDeptType("LEAD_DEPT");//sourceId:107295_1
            omsVirtualOrgMemberDept.setVirtualOrgDeptStatus("牵头部门");//CUSTOM_CONVENTION//sourceId:107302_1
            omsVirtualOrgMemberDept.setIsDisplay("TRUE");//sourceId:107297_1
            omsVirtualOrgMemberDept.setTableTypeCode("OMS_TARGET");//sourceId:107298_1
            omsVirtualOrgMemberDept.setEvaluationTemplateType("EVA_TEMP");//sourceId:167494_1
            omsVirtualOrgMemberDept.setUseScene("TARGET_PLAN_SCENE");//sourceId:1559826_1
            omsVirtualOrgMemberDept.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:107303_1
            if (string_4 != null) {
                omsVirtualOrgMemberDept.setVirtualOrgId(string_4);//SimpleFieldAssign//sourceId:107294_1
            }
            if (omsEvaluationTemplate != null) {
                omsVirtualOrgMemberDept.setDeptId(omsEvaluationTemplate.getDeptId());//SimpleFieldAssign//sourceId:107296_1
                omsVirtualOrgMemberDept.setEntityId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:107299_1
                omsVirtualOrgMemberDept.setBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:107300_1
                omsVirtualOrgMemberDept.setCreateBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:1559827_1
            }
            if (implementWorkGroupStartTimeComRespDto != null) {
                omsVirtualOrgMemberDept.setStartTime(implementWorkGroupStartTimeComRespDto.getComTimeField());//SimpleFieldAssign//sourceId:379924_1
            }
            if (reqDto != null) {
                omsVirtualOrgMemberDept.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:167492_1
            }

            /*3-6-03新增牵头部门[2355]   */
            Assert.isNull(omsVirtualOrgMemberDept.getVirtualOrgId(), "D3-2新增评价画像相关-3-6-03新增牵头部门-虚拟组织ID 不能为空", false);
            Assert.isNull(omsVirtualOrgMemberDept.getDeptType(), "D3-2新增评价画像相关-3-6-03新增牵头部门-部门类型编码不能为空", false);
            Assert.isNull(omsVirtualOrgMemberDept.getDeptId(), "D3-2新增评价画像相关-3-6-03新增牵头部门-虚拟组织下部门ID不能为空", false);
            Assert.isNull(omsVirtualOrgMemberDept.getVirtualOrgDeptStatus(), "D3-2新增评价画像相关-3-6-03新增牵头部门-组织内部门身份名称不能为空", false);
            Assert.isNull(omsVirtualOrgMemberDept.getIsDisplay(), "D3-2新增评价画像相关-3-6-03新增牵头部门-是否外部展示不能为空", false);
            Assert.isNull(omsVirtualOrgMemberDept.getTableTypeCode(), "D3-2新增评价画像相关-3-6-03新增牵头部门-冗余内容表类型编码不能为空", false);
            Assert.isNull(omsVirtualOrgMemberDept.getEntityId(), "D3-2新增评价画像相关-3-6-03新增牵头部门-冗余内容表主键ID不能为空", false);
            Assert.isNull(omsVirtualOrgMemberDept.getEvaluationTemplateType(), "D3-2新增评价画像相关-3-6-03新增牵头部门-归属对象类型不能为空", false);
            Assert.isNull(omsVirtualOrgMemberDept.getEvaluationTemplateId(), "D3-2新增评价画像相关-3-6-03新增牵头部门-归属对象ID不能为空", false);
            Assert.isNull(omsVirtualOrgMemberDept.getBatchCode(), "D3-2新增评价画像相关-3-6-03新增牵头部门-批次标识不能为空", false);
            Assert.isNull(omsVirtualOrgMemberDept.getCreateBatchCode(), "D3-2新增评价画像相关-3-6-03新增牵头部门-创建于批次标识不能为空", false);
            Assert.isNull(omsVirtualOrgMemberDept.getUseScene(), "D3-2新增评价画像相关-3-6-03新增牵头部门-虚拟组织使用场景不能为空", false);
            Assert.isNull(omsVirtualOrgMemberDept.getOrderNumber(), "D3-2新增评价画像相关-3-6-03新增牵头部门-排序不能为空", false);
            string_6 = mOmsVirtualOrgMemberDeptService.addVirtualOrgMemberDept(omsVirtualOrgMemberDept)/*vcase invoke 本地 method 方法调用;*/;


            string_7 = string_6;
        }

//步骤8: D1-3查询个人就职记录信息详情（公共） - queryInductionRecordInfoDetailCom
        QueryInductionRecordInfoDetailComRespDto queryInductionRecordInfoDetailComRespDto = null;
        QueryInductionRecordInfoDetailComReqDto queryInductionRecordInfoDetailComReqDto = new QueryInductionRecordInfoDetailComReqDto();
        queryInductionRecordInfoDetailComReqDto.setInductionRecordId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:108863_1
        queryInductionRecordInfoDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:315169_1

        /*D1-3查询个人就职记录信息详情（公共）[715]   */
        Assert.isNull(queryInductionRecordInfoDetailComReqDto.getSpaceId(), "D3-2新增评价画像相关-D1-3查询个人就职记录信息详情（公共）-创建于空间ID不能为空", false);
        queryInductionRecordInfoDetailComRespDto = inductionRecordService.queryInductionRecordInfoDetailCom(queryInductionRecordInfoDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
        Assert.isTrue(queryInductionRecordInfoDetailComRespDto == null || queryInductionRecordInfoDetailComRespDto.getInductionRecordId() == null, "找不到数据，系统异常", false);


//步骤9: 3-6-02新增虚拟组织成员 - addVirtualOrgMember
        String string_8 = null;
        if (string_4 != null) {
            OmsVirtualOrgMember omsVirtualOrgMember = new OmsVirtualOrgMember();
            omsVirtualOrgMember.setRoleCode("PRINCIPAL");//CUSTOM_CONVENTION//sourceId:107307_1
            omsVirtualOrgMember.setVirtualOrganizationPosition("负责人");//CUSTOM_CONVENTION//sourceId:107308_1
            omsVirtualOrgMember.setIsAdmin("TRUE");//sourceId:107310_1
            omsVirtualOrgMember.setIsUpperLowerLevels("TRUE");//sourceId:167496_1
            omsVirtualOrgMember.setIsDirectStakeholders("TRUE");//sourceId:107311_1
            omsVirtualOrgMember.setIsPersonCharge("TRUE");//sourceId:107312_1
            omsVirtualOrgMember.setIsDisplay("FALSE");//sourceId:107313_1
            omsVirtualOrgMember.setTableTypeCode("OMS_TARGET");//sourceId:107314_1
            omsVirtualOrgMember.setEvaluationTemplateType("EVA_TEMP");//sourceId:167500_1
            omsVirtualOrgMember.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:107319_1
            omsVirtualOrgMember.setUseScene("TARGET_PLAN_SCENE");//sourceId:1559828_1
            if (string_4 != null) {
                omsVirtualOrgMember.setVirtualOrgId(string_4);//SimpleFieldAssign//sourceId:107304_1
            }
            if (queryInductionRecordInfoDetailComRespDto != null) {
                omsVirtualOrgMember.setVirtualOrgInductionRecordId(queryInductionRecordInfoDetailComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:107305_1
                omsVirtualOrgMember.setUserId(queryInductionRecordInfoDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:107306_1
                omsVirtualOrgMember.setFirstLetter(queryInductionRecordInfoDetailComRespDto.getFirstLetter());//SimpleFieldAssign//sourceId:107318_1
                omsVirtualOrgMember.setOriginalRoleMemberId(queryInductionRecordInfoDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:374845_1
            }
            if (implementWorkGroupStartTimeComRespDto != null) {
                omsVirtualOrgMember.setInductionStartTime(implementWorkGroupStartTimeComRespDto.getComTimeField());//SimpleFieldAssign//sourceId:379977_1
            }
            if (omsEvaluationTemplate != null) {
                omsVirtualOrgMember.setEntityId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:107315_1
                omsVirtualOrgMember.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:158731_1
                omsVirtualOrgMember.setBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:107316_1
                omsVirtualOrgMember.setCreateBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:1559829_1
            }

            /*3-6-02新增负责人[2353]   */
            Assert.isNull(omsVirtualOrgMember.getVirtualOrgId(), "D3-2新增评价画像相关-3-6-02新增负责人-虚拟组织ID不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getVirtualOrgInductionRecordId(), "D3-2新增评价画像相关-3-6-02新增负责人-虚拟组织成员就职记录ID不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getUserId(), "D3-2新增评价画像相关-3-6-02新增负责人-个人账号不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getFirstLetter(), "D3-2新增评价画像相关-3-6-02新增负责人-备注首位字母不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getOriginalRoleMemberId(), "D3-2新增评价画像相关-3-6-02新增负责人-身份人员ID不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getRoleCode(), "D3-2新增评价画像相关-3-6-02新增负责人-角色标识不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getVirtualOrganizationPosition(), "D3-2新增评价画像相关-3-6-02新增负责人-组内职务名称不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getIsAdmin(), "D3-2新增评价画像相关-3-6-02新增负责人-是否管理员不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getIsUpperLowerLevels(), "D3-2新增评价画像相关-3-6-02新增负责人-是否上下级关系不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getIsDirectStakeholders(), "D3-2新增评价画像相关-3-6-02新增负责人-是否直接干系人不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getIsPersonCharge(), "D3-2新增评价画像相关-3-6-02新增负责人-是否负责人不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getIsDisplay(), "D3-2新增评价画像相关-3-6-02新增负责人-是否外部展示不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getEntityId(), "D3-2新增评价画像相关-3-6-02新增负责人-冗余内容表主键ID不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getTableTypeCode(), "D3-2新增评价画像相关-3-6-02新增负责人-冗余内容表类型编码不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getEvaluationTemplateId(), "D3-2新增评价画像相关-3-6-02新增负责人-归属对象ID不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getEvaluationTemplateType(), "D3-2新增评价画像相关-3-6-02新增负责人-归属对象类型不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getOrderNumber(), "D3-2新增评价画像相关-3-6-02新增负责人-排序不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getUseScene(), "D3-2新增评价画像相关-3-6-02新增负责人-虚拟组织使用场景不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getBatchCode(), "D3-2新增评价画像相关-3-6-02新增负责人-批次标识不能为空", false);
            Assert.isNull(omsVirtualOrgMember.getCreateBatchCode(), "D3-2新增评价画像相关-3-6-02新增负责人-创建于批次标识不能为空", false);
            string_8 = mOmsVirtualOrgMemberService.addVirtualOrgMember(omsVirtualOrgMember)/*vcase invoke 本地 method 方法调用;*/;


            string_9 = string_8;
        }

//步骤10: 3-6-02修改虚拟组织成员 - updateVirtualOrgMember
        boolean bOOLEAN;
        if (string_8 != null) {
            OmsVirtualOrgMember omsVirtualOrgMember_1 = new OmsVirtualOrgMember();
            omsVirtualOrgMember_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:869249_1
            if (string_8 != null) {
                omsVirtualOrgMember_1.setVirtualOrgMemberId(string_8);//SimpleFieldAssign//sourceId:869248_1
            }

            /*3-6-02更新管理员为当前有效[2612]   */
            Assert.isNull(omsVirtualOrgMember_1.getVirtualOrgMemberId(), "D3-2新增评价画像相关-3-6-02更新管理员为当前有效-虚拟组织成员ID不能为空", false);
            Assert.isNull(omsVirtualOrgMember_1.getSubjectLifeCycle(), "D3-2新增评价画像相关-3-6-02更新管理员为当前有效-主体生命周期不能为空", false);
            bOOLEAN = mOmsVirtualOrgMemberService.updateVirtualOrgMember(omsVirtualOrgMember_1)/*vcase invoke 本地 method 方法调用;*/;


        }

        AddEvaPortraitRelatedRespDto retData = new AddEvaPortraitRelatedRespDto();
        if (string_1 != null) {
            retData.setEvaluationPortraitId(string_1);//SimpleFieldAssign//sourceId:376035_1
        }
        if (string_3 != null) {
            retData.setEvaluationObjectId(string_3);//SimpleFieldAssign//sourceId:108783_1
        }
        if (addEvaFillRoleComRespDto_1 != null) {
            retData.setEvaluationFillRoleId(addEvaFillRoleComRespDto_1.getEvaluationFillRoleId());//SimpleFieldAssign//sourceId:376040_1
        }
        if (string_5 != null) {
            retData.setVirtualOrgId(string_5);//SimpleFieldAssign//sourceId:108779_1
        }
        if (string_7 != null) {
            retData.setVirtualOrgMemberDeptId(string_7);//SimpleFieldAssign//sourceId:108780_1
        }
        if (string_9 != null) {
            retData.setVirtualOrgMemberId(string_9);//SimpleFieldAssign//sourceId:108781_1
        }


        return retData;
    }

    /**
     * D3-2发布批次处理评价模板更新状态(公共)[3617]
     * gen by moon at 10/27/2022, 4:16:52 PM
     */
    @Trace(operationName = "D3-2发布批次处理评价模板更新状态(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ReleaseBatchHandleEvaTempUpdStatusComRespDto releaseBatchHandleEvaTempUpdStatusCom(ReleaseBatchHandleEvaTempUpdStatusComReqDto reqDto) {


        //virtualUsage 3-2-02查评价模板详情  10327
        OmsEvaluationTemplate omsEvaluationTemplate = null;
        QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
        queryEvaTempDetailReq.setUpdateStatus("NEW");//sourceId:162486_1_10327
        if (reqDto != null) {
            queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:162396_1_10327
            queryEvaTempDetailReq.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:162424_1_10327
        }

        /*3-2-02查评价模板详情[2316]   */
        Assert.isNull(queryEvaTempDetailReq.getBatchCode(), "D3-2发布批次处理评价模板更新状态(公共)-3-2-02查评价模板详情-批次标识不能为空", false);
        Assert.isNull(queryEvaTempDetailReq.getUpdateStatus(), "D3-2发布批次处理评价模板更新状态(公共)-3-2-02查评价模板详情-批次下更新状态不能为空", false);
        omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq);


        if ((omsEvaluationTemplate != null)) {
            //if(3-2-02查批次下是否有正在编辑评价模板.出参 值不等于空 )  10328

            boolean bOOLEAN;
            if (omsEvaluationTemplate != null) {
                OmsEvaluationTemplate omsEvaluationTemplate_2 = new OmsEvaluationTemplate();
                omsEvaluationTemplate_2.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:162432_1_10329
                omsEvaluationTemplate_2.setIsUpdate("FALSE");//sourceId:162433_1_10329
                omsEvaluationTemplate_2.setUpdateStatus("UNCHANGED");//sourceId:162434_1_10329
                omsEvaluationTemplate_2.setIsEditing("FALSE");//sourceId:162435_1_10329
                omsEvaluationTemplate_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:162436_1_10329
                omsEvaluationTemplate_2.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:162482_1_10329
                omsEvaluationTemplate_2.setReleaseTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:162483_1_10329
                if (omsEvaluationTemplate != null) {
                    omsEvaluationTemplate_2.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:162420_1_10329
                }

                /*3-2-02修改评价模板[2393]   */
                Assert.isNull(omsEvaluationTemplate_2.getEvaluationTemplateId(), "D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-评价模板ID不能为空", false);
                Assert.isNull(omsEvaluationTemplate_2.getBatchStartTime(), "D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-批次开始时间不能为空", false);
                Assert.isNull(omsEvaluationTemplate_2.getIsUpdate(), "D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-批次下是否更新不能为空", false);
                Assert.isNull(omsEvaluationTemplate_2.getUpdateStatus(), "D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-批次下更新状态不能为空", false);
                Assert.isNull(omsEvaluationTemplate_2.getIsEditing(), "D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-是否未来不能为空", false);
                Assert.isNull(omsEvaluationTemplate_2.getSubjectLifeCycle(), "D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-主体生命周期不能为空", false);
                Assert.isNull(omsEvaluationTemplate_2.getReleaseInductionId(), "D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-发布人就职记录ID不能为空", false);
                Assert.isNull(omsEvaluationTemplate_2.getReleaseTime(), "D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-发布时间不能为空", false);
                bOOLEAN = mOmsEvaluationTemplateService.updateEvaTemp(omsEvaluationTemplate_2);


            }
//processBranchName:正常结束 ,processBranchId:10330

        }
        ReleaseBatchHandleEvaTempUpdStatusComRespDto retData = new ReleaseBatchHandleEvaTempUpdStatusComRespDto();


        return retData;
    }

    /**
     * D3-2检查是否参与评价工作[3228]
     * gen by moon at 11/30/2022, 2:32:39 AM
     */
    @Trace(operationName = "D3-2检查是否参与评价工作")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public CheckIsOpenEvaRespDto checkIsOpenEva(CheckIsOpenEvaReqDto reqDto) {


        AddOutputParametersRespDto receptionServiceRes_1 = null;
        ImplementOutputParametersRespDto receptionServiceRes_3 = null;
//virtualUsage D2-3查询配置项匹配结果转答案(是否开启评价工作)  6665
        QueryItemMatchResultToAnswerDetailComRespDto queryItemMatchResultToAnswerDetailComRespDto = null;
        QueryItemMatchResultToAnswerDetailComReqDto queryItemMatchResultToAnswerDetailComReqDto = new QueryItemMatchResultToAnswerDetailComReqDto();
        queryItemMatchResultToAnswerDetailComReqDto.setConfItemCode("IS_OPEN_EVA_WORK");//CUSTOM_CONVENTION//sourceId:122981_1_6665
        queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:122982_1_6665
        queryItemMatchResultToAnswerDetailComReqDto.setIsInitialScheme("TRUE");//sourceId:308471_1_6665
        queryItemMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:308472_1_6665
        if (reqDto != null) {
            queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:122983_1_6665
        }

        /*D2-3查询配置项匹配结果转答案(是否开启评价工作)[3094]   */
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjId(), "D3-2检查是否参与评价工作-D2-3查询配置项匹配结果转答案(是否开启评价工作)-答案归属对象ID不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getConfItemCode(), "D3-2检查是否参与评价工作-D2-3查询配置项匹配结果转答案(是否开启评价工作)-配置项标识不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjType(), "D3-2检查是否参与评价工作-D2-3查询配置项匹配结果转答案(是否开启评价工作)-答案归属对象类型不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getIsInitialScheme(), "D3-2检查是否参与评价工作-D2-3查询配置项匹配结果转答案(是否开启评价工作)-是否初始方案答案不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getIsPlatData(), "D3-2检查是否参与评价工作-D2-3查询配置项匹配结果转答案(是否开启评价工作)-是否标准答案不能为空", false);
        queryItemMatchResultToAnswerDetailComRespDto = confSchemeService.queryItemMatchResultToAnswerDetailCom(queryItemMatchResultToAnswerDetailComReqDto).getData();


//virtualUsage 3-6-02查虚拟组织成员列表  6666
        List<OmsVirtualOrgMember> listOmsVirtualOrgMember = new ArrayList<>();
        QueryVirtualOrgMemberListReq queryVirtualOrgMemberListReq = new QueryVirtualOrgMemberListReq();
        queryVirtualOrgMemberListReq.setVirtualOrgInductionRecordId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:122747_1_6666
        queryVirtualOrgMemberListReq.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:122741_1_6666
        queryVirtualOrgMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:122742_1_6666
        if (reqDto != null) {
            queryVirtualOrgMemberListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:122750_1_6666
        }

        /*3-6-02查虚拟组织成员列表[2201]   */
        Assert.isNull(queryVirtualOrgMemberListReq.getEntityId(), "D3-2检查是否参与评价工作-3-6-02查虚拟组织成员列表-冗余内容表主键ID不能为空", false);
        Assert.isNull(queryVirtualOrgMemberListReq.getVirtualOrgInductionRecordId(), "D3-2检查是否参与评价工作-3-6-02查虚拟组织成员列表-虚拟组织成员就职记录ID不能为空", false);
        Assert.isNull(queryVirtualOrgMemberListReq.getTableTypeCode(), "D3-2检查是否参与评价工作-3-6-02查虚拟组织成员列表-冗余内容表类型编码不能为空", false);
        Assert.isNull(queryVirtualOrgMemberListReq.getSubjectLifeCycle(), "D3-2检查是否参与评价工作-3-6-02查虚拟组织成员列表-主体生命周期不能为空", false);
        listOmsVirtualOrgMember = mOmsVirtualOrgMemberService.queryVirtualOrgMemberList(queryVirtualOrgMemberListReq);


//virtualUsage 3-2-06查询评价填报角色列表ByCodes  6667
        List<OmsEvaluationFillRole> listOmsEvaluationFillRole = new ArrayList<>();
        if (listOmsVirtualOrgMember != null && !CollectionUtil.isEmpty(listOmsVirtualOrgMember) && listOmsVirtualOrgMember.size() > 0) {
            BatchQueryEvaFillRoleListByCodesReq batchQueryEvaFillRoleListByCodesReq = new BatchQueryEvaFillRoleListByCodesReq();
            batchQueryEvaFillRoleListByCodesReq.setEvaFillRoleList(listOmsVirtualOrgMember.stream().map(item -> item.getRoleCode())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:122734_1_6667
            if (reqDto != null) {
                batchQueryEvaFillRoleListByCodesReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:122735_1_6667
                batchQueryEvaFillRoleListByCodesReq.setRoleTypeCode(reqDto.getRoleTypeCode());//SimpleFieldAssign//sourceId:122737_1_6667
            }

            /*3-2-06查询评价填报角色列表ByCodes[3230]   */
            Assert.isNull(batchQueryEvaFillRoleListByCodesReq.getEvaluationTemplateId(), "D3-2检查是否参与评价工作-3-2-06查询评价填报角色列表ByCodes-评价模板ID不能为空", false);
            Assert.isNull(batchQueryEvaFillRoleListByCodesReq.getRoleTypeCode(), "D3-2检查是否参与评价工作-3-2-06查询评价填报角色列表ByCodes-评价填报角色类型编码不能为空", false);
            listOmsEvaluationFillRole = mOmsEvaluationFillRoleService.batchQueryEvaFillRoleListByCodes(batchQueryEvaFillRoleListByCodesReq);


        }
        if ((queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getIsOpenEvaWork() != null && queryItemMatchResultToAnswerDetailComRespDto.getIsOpenEvaWork().equals("TRUE") && listOmsEvaluationFillRole != null && listOmsEvaluationFillRole != null && listOmsEvaluationFillRole.size() > 0)) {
            //if((D2-3查询配置项匹配结果转答案(是否开启评价工作).是否开启评价工作 等于 是 and 3-2-06查询评价填报角色列表ByCodes.评价填报角色列表数据集条数 大于 0))  6668

//ModelCode: receptionService
            AddOutputParametersRespDto receptionServiceRes = null;
            AddOutputParametersReqDto receptionServiceReq = new AddOutputParametersReqDto();
            receptionServiceReq.setIsOpenEvaWork("TRUE");//sourceId:312650_1_6669

            /*模板开启评价工作[2888] 第一个分支返回：TRUE，第二个分支返回：FALSE 用于特殊方法接收上游入参。 */

            receptionServiceRes = nbEvaTheme.addOutputParameters(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
//processBranchName:正常结束 ,processBranchId:15911

        } else {
            //else  6670

//ModelCode: receptionService
            ImplementOutputParametersRespDto receptionServiceRes_2 = null;
            ImplementOutputParametersReqDto receptionServiceReq_1 = new ImplementOutputParametersReqDto();
            receptionServiceReq_1.setIsOpenEvaWork("FALSE");//sourceId:312658_1_15910

            /*模板未开启评价工作[2888]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getIsOpenEvaWork(), "D3-2检查是否参与评价工作-模板未开启评价工作-是否开启评价工作不能为空", false);
            receptionServiceRes_2 = nbEvaTheme.implementOutputParameters(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
//processBranchName:正常结束 ,processBranchId:15912

        }
        CheckIsOpenEvaRespDto retData = new CheckIsOpenEvaRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setIsOpenEvaWork(receptionServiceRes_1.getIsOpenEvaWork());//SimpleFieldAssign//sourceId:123055_1
        }
        if (receptionServiceRes_3 != null) {
            retData.setIsOpenEvaWork(receptionServiceRes_3.getIsOpenEvaWork());//SimpleFieldAssign//sourceId:123055_1
        }


        return retData;
    }

    /**
     * D3-3新增评价模板判断[4500]
     * gen by moon at 5/6/2023, 3:08:47 PM
     */
    @Trace(operationName = "D3-3新增评价模板判断")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryAddEvaTempJudgeDetailRespDto queryAddEvaTempJudgeDetail(QueryAddEvaTempJudgeDetailReqDto reqDto) {


        ObtainReceiveOutFieldRespDto receptionServiceRes_1 = null;
        QuerySchemeImpowerCaseDetailComRespDto querySchemeImpowerCaseDetailComRespDto_1 = null;
//virtualUsage D1-2查询当前用户就职记录权限(公共)  16194
        QueryCurrentUserRecordTributPowerDetailComRespDto queryCurrentUserRecordTributPowerDetailComRespDto = null;
        QueryCurrentUserRecordTributPowerDetailComReqDto queryCurrentUserRecordTributPowerDetailComReqDto = new QueryCurrentUserRecordTributPowerDetailComReqDto();
        queryCurrentUserRecordTributPowerDetailComReqDto.setAllocationObjectId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:322917_1_16194
        queryCurrentUserRecordTributPowerDetailComReqDto.setTypeCode("PERSONAL_DEPARTMENT");//sourceId:332224_1_16194
        queryCurrentUserRecordTributPowerDetailComReqDto.setPrivacyCategory("SUB_DATA_PRIVACY");//sourceId:332225_1_16194
        queryCurrentUserRecordTributPowerDetailComReqDto.setBusinessPurposes("ALL");//sourceId:332226_1_16194
        if (reqDto != null) {
            queryCurrentUserRecordTributPowerDetailComReqDto.setPrivacyCode(reqDto.getPrivacyCode());//SimpleFieldAssign//sourceId:322920_1_16194
        }

        /*D1-2查询当前用户就职记录权限(公共)[4546]   */
        Assert.isNull(queryCurrentUserRecordTributPowerDetailComReqDto.getPrivacyCode(), "D3-3新增评价模板判断-D1-2查询当前用户就职记录权限(公共)-权限标识不能为空", false);
        Assert.isNull(queryCurrentUserRecordTributPowerDetailComReqDto.getAllocationObjectId(), "D3-3新增评价模板判断-D1-2查询当前用户就职记录权限(公共)-分配对象ID不能为空", false);
        Assert.isNull(queryCurrentUserRecordTributPowerDetailComReqDto.getTypeCode(), "D3-3新增评价模板判断-D1-2查询当前用户就职记录权限(公共)-分配对象类型编码不能为空", false);
        Assert.isNull(queryCurrentUserRecordTributPowerDetailComReqDto.getPrivacyCategory(), "D3-3新增评价模板判断-D1-2查询当前用户就职记录权限(公共)-权限类别不能为空", false);
        Assert.isNull(queryCurrentUserRecordTributPowerDetailComReqDto.getBusinessPurposes(), "D3-3新增评价模板判断-D1-2查询当前用户就职记录权限(公共)-权限业务用途不能为空", false);
        queryCurrentUserRecordTributPowerDetailComRespDto = powerService.queryCurrentUserRecordTributPowerDetailCom(queryCurrentUserRecordTributPowerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((queryCurrentUserRecordTributPowerDetailComRespDto != null && queryCurrentUserRecordTributPowerDetailComRespDto.getPrivacyCode() != null)) {
            //if(D1-2查询当前用户就职记录权限(公共).权限标识 值不等于空 )  19351

//ModelCode: receptionService
            ObtainReceiveOutFieldRespDto receptionServiceRes = null;
            ObtainReceiveOutFieldReqDto receptionServiceReq = new ObtainReceiveOutFieldReqDto();
            receptionServiceReq.setOutputNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:374677_1_19352

            /*M3有新增模板权限[4608]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getOutputNum(), "D3-3新增评价模板判断-M3有新增模板权限-传输数值（整数型）不能为空", false);
            receptionServiceRes = nbEvaTheme.obtainReceiveOutField(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
        }
//virtualUsage D2-3查询方案授权情况(公共)  16517
        QuerySchemeImpowerCaseDetailComRespDto querySchemeImpowerCaseDetailComRespDto = null;
        QuerySchemeImpowerCaseDetailComReqDto querySchemeImpowerCaseDetailComReqDto = new QuerySchemeImpowerCaseDetailComReqDto();
        if (reqDto != null) {
            querySchemeImpowerCaseDetailComReqDto.setConfSchemeCode(reqDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:333728_1_16517
        }

        /*D2-3查询方案授权情况(公共)[4584]   */
        Assert.isNull(querySchemeImpowerCaseDetailComReqDto.getConfSchemeCode(), "D3-3新增评价模板判断-D2-3查询方案授权情况(公共)-配置方案标识不能为空", false);
        querySchemeImpowerCaseDetailComRespDto = fwCompSchemeOpenRecordClient.querySchemeImpowerCaseDetailCom(querySchemeImpowerCaseDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        querySchemeImpowerCaseDetailComRespDto_1 = querySchemeImpowerCaseDetailComRespDto;
//processBranchName:正常结束 ,processBranchId:24368

        QueryAddEvaTempJudgeDetailRespDto retData = new QueryAddEvaTempJudgeDetailRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setIsVisible(receptionServiceRes_1.getOutputNum());//SimpleFieldAssign//sourceId:499221_1
        }
        if (querySchemeImpowerCaseDetailComRespDto_1 != null) {
            retData.setIsUsable(querySchemeImpowerCaseDetailComRespDto_1.getOutputNum());//SimpleFieldAssign//sourceId:499220_1
            retData.setEndValue(querySchemeImpowerCaseDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:333740_1
        }


        return retData;
    }

    /**
     * D3-删除评价填报人员(公共)[4598]
     * gen by moon at 5/5/2023, 10:03:23 PM
     */
    @Trace(operationName = "D3-删除评价填报人员(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteEvaFillMemberComRespDto deleteEvaFillMemberCom(DeleteEvaFillMemberComReqDto reqDto) {


        //步骤0: 3-2-07查询评价填报人员列表 - queryEvaFillMemberList
        List<OmsEvaluationFillMember> listOmsEvaluationFillMember = new ArrayList<>();
        OmsEvaluationFillMember omsEvaluationFillMember = new OmsEvaluationFillMember();
        if (reqDto != null) {
            omsEvaluationFillMember.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334582_1
        }

        /*3-2-07查询评价填报人员列表[4215]   */
        Assert.isNull(omsEvaluationFillMember.getEvaluationTemplateId(), "D3-删除评价填报人员(公共)-3-2-07查询评价填报人员列表-评价模板ID不能为空", false);
        listOmsEvaluationFillMember = mOmsEvaluationFillMemberService.queryEvaFillMemberList(omsEvaluationFillMember)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 3-2-07批量删评价填报人员 - batchDeleteEvaFillMember
        boolean bOOLEAN;
        if (listOmsEvaluationFillMember != null && !CollectionUtil.isEmpty(listOmsEvaluationFillMember) && listOmsEvaluationFillMember.size() > 0) {
            List<String> listString = new ArrayList<>();
            if (listOmsEvaluationFillMember != null && !CollectionUtil.isEmpty(listOmsEvaluationFillMember) && listOmsEvaluationFillMember != null && !CollectionUtil.isEmpty(listOmsEvaluationFillMember)) {
                listString = listOmsEvaluationFillMember.stream().map(item -> item.getEvaluationFillMemberId())
                        .collect(Collectors.toList());/*list-to-strings*///sourceId:334584_1
            }

            /*3-2-07批量删评价填报人员[4217]   */

            bOOLEAN = mOmsEvaluationFillMemberService.batchDeleteEvaFillMember(listString)/*vcase invoke 本地 method 方法调用;*/;


        }

        DeleteEvaFillMemberComRespDto retData = new DeleteEvaFillMemberComRespDto();


        return retData;
    }

    /**
     * D3-删除评价填报角色(公共)[4597]
     * gen by moon at 5/5/2023, 10:03:26 PM
     */
    @Trace(operationName = "D3-删除评价填报角色(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteEvaFillRoleComRespDto deleteEvaFillRoleCom(DeleteEvaFillRoleComReqDto reqDto) {


        //步骤0: 3-2-06查评价填报角色列表 - queryEvaFillRoleList
        List<OmsEvaluationFillRole> listOmsEvaluationFillRole = new ArrayList<>();
        QueryEvaFillRoleListReq queryEvaFillRoleListReq = new QueryEvaFillRoleListReq();
        if (reqDto != null) {
            queryEvaFillRoleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334574_1
        }

        /*3-2-06查评价填报角色列表[2369]   */
        Assert.isNull(queryEvaFillRoleListReq.getEvaluationTemplateId(), "D3-删除评价填报角色(公共)-3-2-06查评价填报角色列表-评价模板ID不能为空", false);
        listOmsEvaluationFillRole = mOmsEvaluationFillRoleService.queryEvaFillRoleList(queryEvaFillRoleListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 3-2-06批量删评价填报角色 - batchDeleteEvaFillRole
        boolean bOOLEAN;
        if (listOmsEvaluationFillRole != null && !CollectionUtil.isEmpty(listOmsEvaluationFillRole) && listOmsEvaluationFillRole.size() > 0) {
            List<String> listString = new ArrayList<>();
            if (listOmsEvaluationFillRole != null && !CollectionUtil.isEmpty(listOmsEvaluationFillRole) && listOmsEvaluationFillRole != null && !CollectionUtil.isEmpty(listOmsEvaluationFillRole)) {
                listString = listOmsEvaluationFillRole.stream().map(item -> item.getEvaluationFillRoleId())
                        .collect(Collectors.toList());/*list-to-strings*///sourceId:334579_1
            }

            /*3-2-06批量删评价填报角色[4213]   */

            bOOLEAN = mOmsEvaluationFillRoleService.batchDeleteEvaFillRole(listString)/*vcase invoke 本地 method 方法调用;*/;


        }

        DeleteEvaFillRoleComRespDto retData = new DeleteEvaFillRoleComRespDto();


        return retData;
    }

    /**
     * D3-删除评价对象(公共)[4596]
     * gen by moon at 3/5/2023, 9:33:41 PM
     */
    @Trace(operationName = "D3-删除评价对象(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteEvaObjectComRespDto deleteEvaObjectCom(DeleteEvaObjectComReqDto reqDto) {


        //步骤0: 3-2-05查询评价对象详情 - queryEvaObjectDetail
        OmsEvaluationObject omsEvaluationObject = null;
        QueryEvaObjectDetailReq queryEvaObjectDetailReq = new QueryEvaObjectDetailReq();
        if (reqDto != null) {
            queryEvaObjectDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334569_1
        }

        /*3-2-05查询评价对象详情[3463]   */
        Assert.isNull(queryEvaObjectDetailReq.getEvaluationTemplateId(), "D3-删除评价对象(公共)-3-2-05查询评价对象详情-评价模板ID不能为空", false);
        omsEvaluationObject = mOmsEvaluationObjectService.queryEvaObjectDetail(queryEvaObjectDetailReq);


//步骤1: 3-2-05删除评价对象 - deleteEvaObject
        boolean bOOLEAN;
        if (omsEvaluationObject != null) {
            String string = new String();
            if (omsEvaluationObject != null) {
                string = omsEvaluationObject.getEvaluationObjectId();
                ;//SimpleFieldAssign//sourceId:334571_1
            }

            /*3-2-05删除评价对象[4210]   */
            Assert.isNull(string, "D3-删除评价对象(公共)-3-2-05删除评价对象-评价对象ID不能为空", false);
            bOOLEAN = mOmsEvaluationObjectService.deleteEvaObject(string);


        }

        DeleteEvaObjectComRespDto retData = new DeleteEvaObjectComRespDto();


        return retData;
    }

    /**
     * D3-3返回评价模板第一步[4609]
     * gen by moon at 5/26/2023, 3:38:36 AM
     */
    @Trace(operationName = "D3-3返回评价模板第一步")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BackToFirstStepEvaTempRespDto backToFirstStepEvaTemp(BackToFirstStepEvaTempReqDto reqDto) {


        //步骤0: 3-2-02查评价模板详情 - queryEvaTempDetail
        OmsEvaluationTemplate omsEvaluationTemplate = null;
        QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
        queryEvaTempDetailReq.setSubjectLifeCycle("EDITING");//sourceId:334518_1
        if (reqDto != null) {
            queryEvaTempDetailReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:334517_1
        }

        /*3-2-02查评价模板详情[2316]   */
        Assert.isNull(queryEvaTempDetailReq.getEvaluationSubjectId(), "D3-3返回评价模板第一步-3-2-02查评价模板详情-归属评价主题ID不能为空", false);
        Assert.isNull(queryEvaTempDetailReq.getSubjectLifeCycle(), "D3-3返回评价模板第一步-3-2-02查评价模板详情-主体生命周期不能为空", false);
        omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;
        Assert.isTrue(omsEvaluationTemplate == null || omsEvaluationTemplate.getEvaluationTemplateId() == null, "找不到数据，系统异常", false);


//步骤1: D3-删除目标(公共) - deleteTargetCom
        DeleteTargetComRespDto deleteTargetComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteTargetComReqDto deleteTargetComReqDto = new DeleteTargetComReqDto();
            if (omsEvaluationTemplate != null) {
                deleteTargetComReqDto.setTargetId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:985002_1
            }

            /*D3-删除目标(公共)[4592]   */
            Assert.isNull(deleteTargetComReqDto.getTargetId(), "D3-3返回评价模板第一步-D3-删除目标(公共)-目标ID不能为空", false);
            deleteTargetComRespDto = indexSystemService.deleteTargetCom(deleteTargetComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤2: D3-删除评价模板批次设置(公共) - deletePlanEvaBatchSetCom
        DeletePlanEvaBatchSetComRespDto deletePlanEvaBatchSetComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeletePlanEvaBatchSetComReqDto deletePlanEvaBatchSetComReqDto = new DeletePlanEvaBatchSetComReqDto();
            if (omsEvaluationTemplate != null) {
                deletePlanEvaBatchSetComReqDto.setBatchSetId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334542_1
            }

            /*D3-删除评价模板批次设置(公共)[4589]   */
            Assert.isNull(deletePlanEvaBatchSetComReqDto.getBatchSetId(), "D3-3返回评价模板第一步-D3-删除评价模板批次设置(公共)-批次设置对象ID不能为空", false);
            deletePlanEvaBatchSetComRespDto = batchService.deletePlanEvaBatchSetCom(deletePlanEvaBatchSetComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤3: D3-删除业务应用批次(公共) - deleteBizAppBatchCom
        DeleteBizAppBatchComRespDto deleteBizAppBatchComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteBizAppBatchComReqDto deleteBizAppBatchComReqDto = new DeleteBizAppBatchComReqDto();
            deleteBizAppBatchComReqDto.setPurposeTypeCode("TOP_EVA_TEMP_MGT");//sourceId:334544_1
            if (omsEvaluationTemplate != null) {
                deleteBizAppBatchComReqDto.setAscriptionObjectId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334545_1
            }

            /*D3-删除业务应用批次(公共)[3606]   */
            Assert.isNull(deleteBizAppBatchComReqDto.getAscriptionObjectId(), "D3-3返回评价模板第一步-D3-删除业务应用批次(公共)-归属对象ID不能为空", false);
            Assert.isNull(deleteBizAppBatchComReqDto.getPurposeTypeCode(), "D3-3返回评价模板第一步-D3-删除业务应用批次(公共)-用途类型编码不能为空", false);
            deleteBizAppBatchComRespDto = batchService.deleteBizAppBatchCom(deleteBizAppBatchComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤4: D3-6删除目标内容虚拟圈子信息(公共) - deleteTargetContVirtualOrgInfoCom
        DeleteTargetContVirtualOrgInfoComRespDto deleteTargetContVirtualOrgInfoComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteTargetContVirtualOrgInfoComReqDto deleteTargetContVirtualOrgInfoComReqDto = new DeleteTargetContVirtualOrgInfoComReqDto();
            deleteTargetContVirtualOrgInfoComReqDto.setTableTypeCode("OMS_TARGET");//sourceId:373865_1
            if (omsEvaluationTemplate != null) {
                deleteTargetContVirtualOrgInfoComReqDto.setEntityId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:373866_1
            }

            /*D3-6删除目标内容虚拟圈子信息(公共)[4793]   */
            Assert.isNull(deleteTargetContVirtualOrgInfoComReqDto.getTableTypeCode(), "D3-3返回评价模板第一步-D3-6删除目标内容虚拟圈子信息(公共)-内容表类型编码不能为空", false);
            Assert.isNull(deleteTargetContVirtualOrgInfoComReqDto.getEntityId(), "D3-3返回评价模板第一步-D3-6删除目标内容虚拟圈子信息(公共)-内容表主键ID不能为空", false);
            deleteTargetContVirtualOrgInfoComRespDto = virtualOrgService.deleteTargetContVirtualOrgInfoCom(deleteTargetContVirtualOrgInfoComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤5: D3-11删除目标内容检查项状态等(公共) - deleteTargetContentCheckItemStatEtcCom
        DeleteTargetContentCheckItemStatEtcComRespDto deleteTargetContentCheckItemStatEtcComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteTargetContentCheckItemStatEtcComReqDto deleteTargetContentCheckItemStatEtcComReqDto = new DeleteTargetContentCheckItemStatEtcComReqDto();
            deleteTargetContentCheckItemStatEtcComReqDto.setTableTypeCode("OMS_TARGET");//sourceId:373873_1
            if (omsEvaluationTemplate != null) {
                deleteTargetContentCheckItemStatEtcComReqDto.setEntityId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:373874_1
            }

            /*D3-11删除目标内容检查项状态等(公共)[4794]   */
            Assert.isNull(deleteTargetContentCheckItemStatEtcComReqDto.getTableTypeCode(), "D3-3返回评价模板第一步-D3-11删除目标内容检查项状态等(公共)-内容表类型编码不能为空", false);
            Assert.isNull(deleteTargetContentCheckItemStatEtcComReqDto.getEntityId(), "D3-3返回评价模板第一步-D3-11删除目标内容检查项状态等(公共)-内容表主键ID不能为空", false);
            deleteTargetContentCheckItemStatEtcComRespDto = offStateService.deleteTargetContentCheckItemStatEtcCom(deleteTargetContentCheckItemStatEtcComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤6: D3-删除当前规划资料(公共) - deleteCurrentPlanDataCom
        DeleteCurrentPlanDataComRespDto deleteCurrentPlanDataComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteCurrentPlanDataComReqDto deleteCurrentPlanDataComReqDto = new DeleteCurrentPlanDataComReqDto();
            if (omsEvaluationTemplate != null) {
                deleteCurrentPlanDataComReqDto.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334982_1
            }

            /*D3-删除当前规划资料(公共)[4594]   */
            Assert.isNull(deleteCurrentPlanDataComReqDto.getEvaluationTemplateId(), "D3-3返回评价模板第一步-D3-删除当前规划资料(公共)-冗余评价模板ID不能为空", false);
            deleteCurrentPlanDataComRespDto = planDataService.deleteCurrentPlanDataCom(deleteCurrentPlanDataComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤7: D3-2删除评价画像(公共) - deleteEvaPortraitCom
        DeleteEvaPortraitComRespDto deleteEvaPortraitComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteEvaPortraitComReqDto deleteEvaPortraitComReqDto = new DeleteEvaPortraitComReqDto();
            if (omsEvaluationTemplate != null) {
                deleteEvaPortraitComReqDto.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:375583_1
            }

            /*D3-2删除评价画像(公共)[4829]   */
            Assert.isNull(deleteEvaPortraitComReqDto.getEvaluationTemplateId(), "D3-3返回评价模板第一步-D3-2删除评价画像(公共)-评价模板ID不能为空", false);
            deleteEvaPortraitComRespDto = deleteEvaPortraitCom(deleteEvaPortraitComReqDto)/*vcase invoke 同服务,同domain*/;


        }

//步骤8: D3-删除评价对象(公共) - deleteEvaObjectCom
        DeleteEvaObjectComRespDto deleteEvaObjectComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteEvaObjectComReqDto deleteEvaObjectComReqDto = new DeleteEvaObjectComReqDto();
            if (omsEvaluationTemplate != null) {
                deleteEvaObjectComReqDto.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334572_1
            }

            /*D3-删除评价对象(公共)[4596]   */
            Assert.isNull(deleteEvaObjectComReqDto.getEvaluationTemplateId(), "D3-3返回评价模板第一步-D3-删除评价对象(公共)-评价模板ID不能为空", false);
            deleteEvaObjectComRespDto = deleteEvaObjectCom(deleteEvaObjectComReqDto)/*vcase invoke 同服务,同domain*/;


        }

//步骤9: D3-删除评价填报角色(公共) - deleteEvaFillRoleCom
        DeleteEvaFillRoleComRespDto deleteEvaFillRoleComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteEvaFillRoleComReqDto deleteEvaFillRoleComReqDto = new DeleteEvaFillRoleComReqDto();
            if (omsEvaluationTemplate != null) {
                deleteEvaFillRoleComReqDto.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334581_1
            }

            /*D3-删除评价填报角色(公共)[4597]   */
            Assert.isNull(deleteEvaFillRoleComReqDto.getEvaluationTemplateId(), "D3-3返回评价模板第一步-D3-删除评价填报角色(公共)-评价模板ID不能为空", false);
            deleteEvaFillRoleComRespDto = deleteEvaFillRoleCom(deleteEvaFillRoleComReqDto)/*vcase invoke 同服务,同domain*/;


        }

//步骤10: D3-删除评价填报人员(公共) - deleteEvaFillMemberCom
        DeleteEvaFillMemberComRespDto deleteEvaFillMemberComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteEvaFillMemberComReqDto deleteEvaFillMemberComReqDto = new DeleteEvaFillMemberComReqDto();
            if (omsEvaluationTemplate != null) {
                deleteEvaFillMemberComReqDto.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334586_1
            }

            /*D3-删除评价填报人员(公共)[4598]   */
            Assert.isNull(deleteEvaFillMemberComReqDto.getEvaluationTemplateId(), "D3-3返回评价模板第一步-D3-删除评价填报人员(公共)-评价模板ID不能为空", false);
            deleteEvaFillMemberComRespDto = deleteEvaFillMemberCom(deleteEvaFillMemberComReqDto)/*vcase invoke 同服务,同domain*/;


        }

//步骤11: D3-3删除被评对象目标周期目标设置(公共) - deleteEvaObjTargetCycleOsetCom
        DeleteEvaObjTargetCycleOsetComRespDto deleteEvaObjTargetCycleOsetComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteEvaObjTargetCycleOsetComReqDto deleteEvaObjTargetCycleOsetComReqDto = new DeleteEvaObjTargetCycleOsetComReqDto();
            deleteEvaObjTargetCycleOsetComReqDto.setTargetCycleContentTypeCode("TARGET");//sourceId:334660_1
            if (omsEvaluationTemplate != null) {
                deleteEvaObjTargetCycleOsetComReqDto.setTargetId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:334659_1
                deleteEvaObjTargetCycleOsetComReqDto.setTargetCycleContentId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:334658_1
            }

            /*D3-3删除被评对象目标周期目标设置(公共)[3246]   */
            Assert.isNull(deleteEvaObjTargetCycleOsetComReqDto.getTargetId(), "D3-3返回评价模板第一步-D3-3删除被评对象目标周期目标设置(公共)-冗余目标ID不能为空", false);
            Assert.isNull(deleteEvaObjTargetCycleOsetComReqDto.getTargetCycleContentId(), "D3-3返回评价模板第一步-D3-3删除被评对象目标周期目标设置(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(deleteEvaObjTargetCycleOsetComReqDto.getTargetCycleContentTypeCode(), "D3-3返回评价模板第一步-D3-3删除被评对象目标周期目标设置(公共)-关联目标内容类型编码不能为空", false);
            deleteEvaObjTargetCycleOsetComRespDto = targetCycleService.deleteEvaObjTargetCycleOsetCom(deleteEvaObjTargetCycleOsetComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤12: D3-3删除执行周期阶段(公共) - deleteExecuteCycleStageCom
        DeleteExecuteCycleStageComRespDto deleteExecuteCycleStageComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteExecuteCycleStageComReqDto deleteExecuteCycleStageComReqDto = new DeleteExecuteCycleStageComReqDto();
            if (omsEvaluationTemplate != null) {
                deleteExecuteCycleStageComReqDto.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334749_1
            }

            /*D3-3删除执行周期阶段(公共)[4612]   */
            Assert.isNull(deleteExecuteCycleStageComReqDto.getEvaluationTemplateId(), "D3-3返回评价模板第一步-D3-3删除执行周期阶段(公共)-评价模板ID不能为空", false);
            deleteExecuteCycleStageComRespDto = targetCycleService.deleteExecuteCycleStageCom(deleteExecuteCycleStageComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤13: D3-3删除评价对象被评对象目标周期(公共) - deleteEvaObjTargetCycleCom
        DeleteEvaObjTargetCycleComRespDto deleteEvaObjTargetCycleComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteEvaObjTargetCycleComReqDto deleteEvaObjTargetCycleComReqDto = new DeleteEvaObjTargetCycleComReqDto();
            deleteEvaObjTargetCycleComReqDto.setTargetCycleContentTypeCode("TARGET");//sourceId:334655_1
            if (omsEvaluationTemplate != null) {
                deleteEvaObjTargetCycleComReqDto.setTargetId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:334657_1
                deleteEvaObjTargetCycleComReqDto.setTargetCycleContentId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:940377_1
            }

            /*D3-3删除评价对象被评对象目标周期(公共)[3247]   */
            Assert.isNull(deleteEvaObjTargetCycleComReqDto.getTargetId(), "D3-3返回评价模板第一步-D3-3删除评价对象被评对象目标周期(公共)-冗余目标ID不能为空", false);
            Assert.isNull(deleteEvaObjTargetCycleComReqDto.getTargetCycleContentId(), "D3-3返回评价模板第一步-D3-3删除评价对象被评对象目标周期(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(deleteEvaObjTargetCycleComReqDto.getTargetCycleContentTypeCode(), "D3-3返回评价模板第一步-D3-3删除评价对象被评对象目标周期(公共)-关联目标内容类型编码不能为空", false);
            deleteEvaObjTargetCycleComRespDto = targetCycleService.deleteEvaObjTargetCycleCom(deleteEvaObjTargetCycleComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤14: D3-2删除定时任务调度(公共) - deleteTimerTaskPlanCom
        DeleteTimerTaskPlanComRespDto deleteTimerTaskPlanComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteTimerTaskPlanComReqDto deleteTimerTaskPlanComReqDto = new DeleteTimerTaskPlanComReqDto();
            if (omsEvaluationTemplate != null) {
                deleteTimerTaskPlanComReqDto.setThemeContentId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:940386_1
            }

            /*D3-2删除定时任务调度(公共)[3306]   */
            Assert.isNull(deleteTimerTaskPlanComReqDto.getThemeContentId(), "D3-3返回评价模板第一步-D3-2删除定时任务调度(公共)-主题内容ID不能为空", false);
            deleteTimerTaskPlanComRespDto = taskGenService.deleteTimerTaskPlanCom(deleteTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤15: D3-12删除内容当前行为步骤(公共) - deleteContCurrentBstepCom
        DeleteContCurrentBstepComRespDto deleteContCurrentBstepComRespDto = null;
        if (omsEvaluationTemplate != null) {
            DeleteContCurrentBstepComReqDto deleteContCurrentBstepComReqDto = new DeleteContCurrentBstepComReqDto();
            deleteContCurrentBstepComReqDto.setStepObj("OMS_EVALUATION_TEMPLATE");//sourceId:374843_1
            if (omsEvaluationTemplate != null) {
                deleteContCurrentBstepComReqDto.setEntityId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:374842_1
            }

            /*D3-12删除内容当前行为步骤(公共)[4623]   */
            Assert.isNull(deleteContCurrentBstepComReqDto.getEntityId(), "D3-3返回评价模板第一步-D3-12删除内容当前行为步骤(公共)-步骤内容实例ID不能为空", false);
            Assert.isNull(deleteContCurrentBstepComReqDto.getStepObj(), "D3-3返回评价模板第一步-D3-12删除内容当前行为步骤(公共)-步骤使用对象表不能为空", false);
            deleteContCurrentBstepComRespDto = offStateService.deleteContCurrentBstepCom(deleteContCurrentBstepComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤16: 3-2-02删除评价模板 - deleteEvaTemp
        boolean bOOLEAN;
        if (omsEvaluationTemplate != null) {
            String string = new String();
            if (omsEvaluationTemplate != null) {
                string = omsEvaluationTemplate.getEvaluationTemplateId();
                ;//SimpleFieldAssign//sourceId:362179_1
            }

            /*3-2-02删除评价模板[4764]   */
            Assert.isNull(string, "D3-3返回评价模板第一步-3-2-02删除评价模板-评价模板ID不能为空", false);
            bOOLEAN = mOmsEvaluationTemplateService.deleteEvaTemp(string)/*vcase invoke 本地 method 方法调用;*/;


        }

//步骤17: D2-3查询配置方案详情(公共) - queryConfSchemeDetailCom
        QueryConfSchemeDetailComRespDto queryConfSchemeDetailComRespDto = null;
        if (omsEvaluationTemplate != null) {
            QueryConfSchemeDetailComReqDto queryConfSchemeDetailComReqDto = new QueryConfSchemeDetailComReqDto();
            if (omsEvaluationTemplate != null) {
                queryConfSchemeDetailComReqDto.setConfSchemeCode(omsEvaluationTemplate.getConfSchemeCode());//SimpleFieldAssign//sourceId:381243_1
            }

            /*D2-3查询配置方案详情(公共)[1981]   */
            Assert.isNull(queryConfSchemeDetailComReqDto.getConfSchemeCode(), "D3-3返回评价模板第一步-D2-3查询配置方案详情(公共)-配置方案标识不能为空", false);
            queryConfSchemeDetailComRespDto = confSchemeService.queryConfSchemeDetailCom(queryConfSchemeDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }

//步骤18: 3-2-01查评价主题详情 - queryEvaThemeDetail
        OmsEvaluationSubject omsEvaluationSubject = null;
        QueryEvaThemeDetailReq queryEvaThemeDetailReq = new QueryEvaThemeDetailReq();
        queryEvaThemeDetailReq.setAscriptionSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:890118_1
        if (reqDto != null) {
            queryEvaThemeDetailReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:890125_1
        }

        /*3-2-01查评价主题【配置方案ID】[2310]   */
        Assert.isNull(queryEvaThemeDetailReq.getEvaluationSubjectId(), "D3-3返回评价模板第一步-3-2-01查评价主题【配置方案ID】-评价主题ID不能为空", false);
        Assert.isNull(queryEvaThemeDetailReq.getAscriptionSpaceId(), "D3-3返回评价模板第一步-3-2-01查评价主题【配置方案ID】-归属空间ID不能为空", false);
        omsEvaluationSubject = mOmsEvaluationSubjectService.queryEvaThemeDetail(queryEvaThemeDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤19: D3新增定时任务调度(公共) - addTimerTaskPlanCom
        AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto = null;
        if (omsEvaluationTemplate != null) {
            AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto = new AddTimerTaskPlanComReqDto();
            addTimerTaskPlanComReqDto.setIsCompensateTask("FALSE");//sourceId:389697_1
            addTimerTaskPlanComReqDto.setDispatchActionTypeCode("DISATCH_DEL_TEMP_CLONE_RESULT_ETC_TASK");//sourceId:389698_1
            addTimerTaskPlanComReqDto.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:389699_1
            addTimerTaskPlanComReqDto.setObjectTypeCode("OMS_CONF_SCHEME");//sourceId:389700_1
            addTimerTaskPlanComReqDto.setAddRuleInfoTypeCode("OMS_CONF_SCHEME");//sourceId:389703_1
            addTimerTaskPlanComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:586321_1
            addTimerTaskPlanComReqDto.setIsComplete("FALSE");//sourceId:389712_1
            addTimerTaskPlanComReqDto.setIsRealTimeaSync("TRUE");//sourceId:731013_1
            addTimerTaskPlanComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:389709_1
            addTimerTaskPlanComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:389710_1
            addTimerTaskPlanComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:389711_1
            if (omsEvaluationTemplate != null) {
                addTimerTaskPlanComReqDto.setTargetContentName(omsEvaluationTemplate.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:389696_1
                addTimerTaskPlanComReqDto.setThemeContentId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:586322_1
            }
            if (queryConfSchemeDetailComRespDto != null) {
                addTimerTaskPlanComReqDto.setObjectId(queryConfSchemeDetailComRespDto.getConfSchemeId());//SimpleFieldAssign//sourceId:389701_1
            }
            if (omsEvaluationSubject != null) {
                addTimerTaskPlanComReqDto.setAddRuleInfoId(omsEvaluationSubject.getConfSchemeId());//SimpleFieldAssign//sourceId:389704_1
            }

            /*D3新增模板克隆答案等任务调度(公共)[4995]   */
            Assert.isNull(addTimerTaskPlanComReqDto.getTargetContentName(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-目标内容名称不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getIsCompensateTask(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-是否补偿任务不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getDispatchActionTypeCode(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-任务调度的行为类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getTaskDispatchTypeCode(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-任务调度类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getObjectTypeCode(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-归属对象类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getObjectId(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-归属对象内容ID不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoTypeCode(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-生成规则信息类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoId(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-生成辅助规则信息值不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentTypeCode(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-主题内容类型编码不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentId(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-主题内容ID不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getIsComplete(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-是否执行完成不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getIsRealTimeaSync(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-是否实时异步调度不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getOperationInductionId(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-操作人就职记录ID不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getSpaceId(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-创建于空间ID不能为空", false);
            Assert.isNull(addTimerTaskPlanComReqDto.getAppId(), "D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-创建于联盟应用ID不能为空", false);
            addTimerTaskPlanComRespDto = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;


        }

//步骤20: D3-2执行删除模板克隆答案等相关(公共) - implementTempCloneResultEtcCom
        ImplementTempCloneResultEtcComRespDto implementTempCloneResultEtcComRespDto = null;
        if (addTimerTaskPlanComRespDto != null) {
            ImplementTempCloneResultEtcComReqDto implementTempCloneResultEtcComReqDto = new ImplementTempCloneResultEtcComReqDto();
            implementTempCloneResultEtcComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:890427_1
            if (addTimerTaskPlanComRespDto != null) {
                implementTempCloneResultEtcComReqDto.setTimingTaskDispatchId(addTimerTaskPlanComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:890426_1
            }

            /*D3-2执行删除模板克隆答案等相关(公共)[4845]   */
            Assert.isNull(implementTempCloneResultEtcComReqDto.getTimingTaskDispatchId(), "D3-3返回评价模板第一步-D3-2执行删除模板克隆答案等相关(公共)-定时任务调度记录ID不能为空", false);
            Assert.isNull(implementTempCloneResultEtcComReqDto.getSpaceId(), "D3-3返回评价模板第一步-D3-2执行删除模板克隆答案等相关(公共)-创建于空间ID不能为空", false);
            implementTempCloneResultEtcComRespDto = implementTempCloneResultEtcCom(implementTempCloneResultEtcComReqDto)/*vcase invoke 同服务,同domain*/;


        }

//步骤21: D3-更新业务服务内容当前步骤(公共) - refreshBizAppServiceContCurrentBstepCom
        RefreshBizAppServiceContCurrentBstepComRespDto refreshBizAppServiceContCurrentBstepComRespDto = null;
        RefreshBizAppServiceContCurrentBstepComReqDto refreshBizAppServiceContCurrentBstepComReqDto = new RefreshBizAppServiceContCurrentBstepComReqDto();
        refreshBizAppServiceContCurrentBstepComReqDto.setStepObj("OMS_EVALUATION_SUBJECT");//sourceId:334723_1
        refreshBizAppServiceContCurrentBstepComReqDto.setBizSceneCode("ADD_EVA_TEMP");//CUSTOM_CONVENTION//sourceId:388576_1
        refreshBizAppServiceContCurrentBstepComReqDto.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:388575_1
        if (reqDto != null) {
            refreshBizAppServiceContCurrentBstepComReqDto.setEntityId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:334675_1
        }

        /*D3-更新业务服务内容当前步骤(公共)[4593]   */
        Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getEntityId(), "D3-3返回评价模板第一步-D3-更新业务服务内容当前步骤(公共)-步骤内容实例ID不能为空", false);
        Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getStepObj(), "D3-3返回评价模板第一步-D3-更新业务服务内容当前步骤(公共)-步骤使用对象表不能为空", false);
        Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getBizSceneCode(), "D3-3返回评价模板第一步-D3-更新业务服务内容当前步骤(公共)-业务场景标识不能为空", false);
        Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getOrderNumber(), "D3-3返回评价模板第一步-D3-更新业务服务内容当前步骤(公共)-排序不能为空", false);
        refreshBizAppServiceContCurrentBstepComRespDto = offStateService.refreshBizAppServiceContCurrentBstepCom(refreshBizAppServiceContCurrentBstepComReqDto)/*vcase invoke isSameApp*/;


        BackToFirstStepEvaTempRespDto retData = new BackToFirstStepEvaTempRespDto();


        return retData;
    }

    /**
     * D3-2查询评价填报角色详情[3333]
     * gen by moon at 11/15/2022, 11:36:13 AM
     */
    @Trace(operationName = "D3-2查询评价填报角色详情")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaFillRoleDetailRespDto queryEvaFillRoleDetail(QueryEvaFillRoleDetailReqDto reqDto) {


        OmsEvaluationFillRole omsEvaluationFillRole_1 = null;
//步骤0: 3-2-06查评价填报角色详情 - queryEvaFillRoleDetail
        OmsEvaluationFillRole omsEvaluationFillRole = null;
        QueryEvaFillRoleDetailReq queryEvaFillRoleDetailReq = new QueryEvaFillRoleDetailReq();
        if (reqDto != null) {
            queryEvaFillRoleDetailReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:131347_1
            queryEvaFillRoleDetailReq.setRoleTypeCode(reqDto.getRoleTypeCode());//SimpleFieldAssign//sourceId:131348_1
            queryEvaFillRoleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:131349_1
            queryEvaFillRoleDetailReq.setIsSystemType(reqDto.getIsSystemType());//SimpleFieldAssign//sourceId:131350_1
            queryEvaFillRoleDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:131351_1
        }

        /*3-2-06查评价填报角色详情[2380]   */

        omsEvaluationFillRole = mOmsEvaluationFillRoleService.queryEvaFillRoleDetail(queryEvaFillRoleDetailReq);


        omsEvaluationFillRole_1 = omsEvaluationFillRole;

        QueryEvaFillRoleDetailRespDto retData = new QueryEvaFillRoleDetailRespDto();
        if (omsEvaluationFillRole_1 != null) {
            retData.setEvaluationFillRoleId(omsEvaluationFillRole_1.getEvaluationFillRoleId());//SimpleFieldAssign//sourceId:131383_1
        }


        return retData;
    }

    /**
     * D3-2查询评价填报人员详情[4316]
     * gen by moon at 11/15/2022, 11:36:20 AM
     */
    @Trace(operationName = "D3-2查询评价填报人员详情")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaFillMemberDetailRespDto queryEvaFillMemberDetail(QueryEvaFillMemberDetailReqDto reqDto) {


        OmsEvaluationFillMember omsEvaluationFillMember_1 = null;
//步骤0: 3-2-07查询评价填报人员详情 - queryEvaFillMemberDetail
        OmsEvaluationFillMember omsEvaluationFillMember = null;
        QueryEvaFillMemberDetailReq queryEvaFillMemberDetailReq = new QueryEvaFillMemberDetailReq();
        queryEvaFillMemberDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:285133_1
        if (reqDto != null) {
            queryEvaFillMemberDetailReq.setEvaluationFillRoleId(reqDto.getEvaluationFillRoleId());//SimpleFieldAssign//sourceId:285128_1
//queryEvaFillMemberDetailReq.setMemberId(reqDto.getMemberId());//SimpleFieldAssign//sourceId:285129_1
            queryEvaFillMemberDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:285130_1
        }

        /*3-2-07查询评价填报人员详情[4314]   */
        Assert.isNull(queryEvaFillMemberDetailReq.getEvaluationFillRoleId(), "D3-2查询评价填报人员详情-3-2-07查询评价填报人员详情-评价填报角色ID不能为空", false);
//Assert.isNull(queryEvaFillMemberDetailReq.getMemberId(),"D3-2查询评价填报人员详情-3-2-07查询评价填报人员详情-关联身份人员ID不能为空",false);
        Assert.isNull(queryEvaFillMemberDetailReq.getEvaluationTemplateId(), "D3-2查询评价填报人员详情-3-2-07查询评价填报人员详情-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaFillMemberDetailReq.getSubjectLifeCycle(), "D3-2查询评价填报人员详情-3-2-07查询评价填报人员详情-主体生命周期不能为空", false);
        omsEvaluationFillMember = mOmsEvaluationFillMemberService.queryEvaFillMemberDetail(queryEvaFillMemberDetailReq);


        omsEvaluationFillMember_1 = omsEvaluationFillMember;

        QueryEvaFillMemberDetailRespDto retData = new QueryEvaFillMemberDetailRespDto();
        if (omsEvaluationFillMember_1 != null) {
            retData.setEvaluationFillMemberId(omsEvaluationFillMember_1.getEvaluationFillMemberId());//SimpleFieldAssign//sourceId:285138_1
        }


        return retData;
    }

    /**
     * D3-3判断新增的评价模板(公共)[4760]
     * gen by moon at 5/1/2023, 10:28:23 PM
     */
    @Trace(operationName = "D3-3判断新增的评价模板(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeAddEvaTempComRespDto judgeAddEvaTempCom(JudgeAddEvaTempComReqDto reqDto) {


        //virtualUsage D3执行评价模板新增条件判断(公共)  38436
        ImplementEvaTempAddTermJudgeComRespDto implementEvaTempAddTermJudgeComRespDto = null;
        ImplementEvaTempAddTermJudgeComReqDto implementEvaTempAddTermJudgeComReqDto = new ImplementEvaTempAddTermJudgeComReqDto();
        if (reqDto != null) {
            implementEvaTempAddTermJudgeComReqDto.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:872602_1_38436
        }

        /*D3执行评价模板新增条件判断(公共)[6410]   */
        Assert.isNull(implementEvaTempAddTermJudgeComReqDto.getEvaluationSubjectId(), "D3-3判断新增的评价模板(公共)-D3执行评价模板新增条件判断(公共)-评价主题ID不能为空", false);
        implementEvaTempAddTermJudgeComRespDto = implementEvaTempAddTermJudgeCom(implementEvaTempAddTermJudgeComReqDto)/*vcase invoke 同服务,同domain*/;


        if ((implementEvaTempAddTermJudgeComRespDto != null && implementEvaTempAddTermJudgeComRespDto.getIsAddEvaTemp() != null && implementEvaTempAddTermJudgeComRespDto != null && implementEvaTempAddTermJudgeComRespDto.getIsAddEvaTemp() != null && implementEvaTempAddTermJudgeComRespDto.getIsAddEvaTemp().equals("0"))) {
            //if((D3执行评价模板新增条件判断(公共).是否允许新增评价模板 值不等于空  and D3执行评价模板新增条件判断(公共).是否允许新增评价模板 等于 0))  38437

//异常结束 38438
            throw new BizException("330000219", "对不起！当前有未公开的评价模板暂不允许新增，请稍后再试~", false);
        } else if ((implementEvaTempAddTermJudgeComRespDto != null && implementEvaTempAddTermJudgeComRespDto.getIsAddEvaTemp() == null)) {
            //elseif(D3执行评价模板新增条件判断(公共).是否允许新增评价模板 值等于空 )  38440

//异常结束 38441
            throw new BizException("C00091", "未知错误，请联系管理员~", false);
        }
        JudgeAddEvaTempComRespDto retData = new JudgeAddEvaTempComRespDto();


        return retData;
    }

    /**
     * D3-2删除评价画像(公共)[4829]
     * gen by moon at 10/15/2022, 5:48:15 PM
     */
    @Trace(operationName = "D3-2删除评价画像(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteEvaPortraitComRespDto deleteEvaPortraitCom(DeleteEvaPortraitComReqDto reqDto) {


        //步骤0: 3-2-04查评价画像详情 - queryEvaPortraitDetail
        OmsEvaluationPortrait omsEvaluationPortrait = null;
        QueryEvaPortraitDetailReq queryEvaPortraitDetailReq = new QueryEvaPortraitDetailReq();
        if (reqDto != null) {
            queryEvaPortraitDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:375580_1
        }

        /*3-2-04查评价画像详情[2408]   */
        Assert.isNull(queryEvaPortraitDetailReq.getEvaluationTemplateId(), "D3-2删除评价画像(公共)-3-2-04查评价画像详情-评价模板ID不能为空", false);
        omsEvaluationPortrait = mOmsEvaluationPortraitService.queryEvaPortraitDetail(queryEvaPortraitDetailReq);


//步骤1: 3-2-04删除评价画像 - deleteEvaPortrait
        boolean bOOLEAN;
        if (omsEvaluationPortrait != null) {
            String string = new String();
            if (omsEvaluationPortrait != null) {
                string = omsEvaluationPortrait.getEvaluationPortraitId();
                ;//SimpleFieldAssign//sourceId:375550_1
            }

            /*3-2-04删除评价画像[4209]   */
            Assert.isNull(string, "D3-2删除评价画像(公共)-3-2-04删除评价画像-评价画像ID不能为空", false);
            bOOLEAN = mOmsEvaluationPortraitService.deleteEvaPortrait(string);


        }

        DeleteEvaPortraitComRespDto retData = new DeleteEvaPortraitComRespDto();


        return retData;
    }

    /**
     * D3-2新增评价填报角色(公共)[4830]
     * gen by moon at 11/4/2023, 3:44:12 PM
     */
    @Trace(operationName = "D3-2新增评价填报角色(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddEvaFillRoleComRespDto addEvaFillRoleCom(AddEvaFillRoleComReqDto reqDto) {


        String string_1 = null;
//步骤0: M3接收外部字段(特殊方法） - obtainReceiveOutField
        //ModelCode: receptionService
        ObtainReceiveOutFieldRespDto receptionServiceRes = null;
        ObtainReceiveOutFieldReqDto receptionServiceReq = new ObtainReceiveOutFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:952855_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:376013_1
            receptionServiceReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:637755_1
            receptionServiceReq.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:376014_1
        }

        /*M3接收字段[4608]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getConfSchemeId(), "D3-2新增评价填报角色(公共)-M3接收字段-配置方案ID 不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D3-2新增评价填报角色(公共)-M3接收字段-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationSubjectId(), "D3-2新增评价填报角色(公共)-M3接收字段-冗余评价主题ID不能为空", false);
        Assert.isNull(receptionServiceReq.getBatchCode(), "D3-2新增评价填报角色(公共)-M3接收字段-批次标识不能为空", false);
        receptionServiceRes = nbEvaTheme.obtainReceiveOutField(receptionServiceReq);


//步骤1: D1-查询角色详情(公共) - queryRoleDetailCom
        QueryRoleDetailComRespDto queryRoleDetailComRespDto = null;
        QueryRoleDetailComReqDto queryRoleDetailComReqDto = new QueryRoleDetailComReqDto();
        queryRoleDetailComReqDto.setRoleCode("INITIATOR");//CUSTOM_CONVENTION//sourceId:375881_1

        /*D1-查询角色详情（牵头人）[2747]   */
        Assert.isNull(queryRoleDetailComReqDto.getRoleCode(), "D3-2新增评价填报角色(公共)-D1-查询角色详情（牵头人）-角色标识不能为空", false);
        queryRoleDetailComRespDto = fwBaseRoleClient.queryRoleDetailCom(queryRoleDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤2: 3-2-06新增评价填报角色 - addEvaFillRole
        String string = null;
        if (queryRoleDetailComRespDto != null) {
            OmsEvaluationFillRole omsEvaluationFillRole = new OmsEvaluationFillRole();
            omsEvaluationFillRole.setRoleTypeCode("APPLICANT");//sourceId:375886_1
            omsEvaluationFillRole.setIsSystemType("TRUE");//sourceId:375888_1
            omsEvaluationFillRole.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:375889_1
            if (queryRoleDetailComRespDto != null) {
                omsEvaluationFillRole.setRoleId(queryRoleDetailComRespDto.getRoleId());//SimpleFieldAssign//sourceId:375892_1
                omsEvaluationFillRole.setRoleCode(queryRoleDetailComRespDto.getRoleCode());//SimpleFieldAssign//sourceId:375885_1
                omsEvaluationFillRole.setRoleName(queryRoleDetailComRespDto.getRoleName());//SimpleFieldAssign//sourceId:375893_1
            }
            if (reqDto != null) {
                omsEvaluationFillRole.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:375887_1
                omsEvaluationFillRole.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:637753_1
                omsEvaluationFillRole.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:375890_1
            }

            /*3-2-06新增填报角色（牵头人）[2449]   */
            Assert.isNull(omsEvaluationFillRole.getRoleId(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-普通角色ID不能为空", false);
            Assert.isNull(omsEvaluationFillRole.getRoleCode(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-普通角色标识不能为空", false);
            Assert.isNull(omsEvaluationFillRole.getRoleName(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-普通角色名称不能为空", false);
            Assert.isNull(omsEvaluationFillRole.getRoleTypeCode(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-评价填报角色类型编码不能为空", false);
            Assert.isNull(omsEvaluationFillRole.getEvaluationTemplateId(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-评价模板ID不能为空", false);
            Assert.isNull(omsEvaluationFillRole.getEvaluationSubjectId(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-冗余评价主题ID不能为空", false);
            Assert.isNull(omsEvaluationFillRole.getIsSystemType(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-是否系统类型不能为空", false);
            Assert.isNull(omsEvaluationFillRole.getOrderNumber(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-排序不能为空", false);
            Assert.isNull(omsEvaluationFillRole.getBatchCode(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-批次标识不能为空", false);
            string = mOmsEvaluationFillRoleService.addEvaFillRole(omsEvaluationFillRole)/*vcase invoke 本地 method 方法调用;*/;


            string_1 = string;
        }

//步骤3: D1-查询角色详情(公共) - queryRoleDetailCom
        QueryRoleDetailComRespDto queryRoleDetailComRespDto_2 = null;
        QueryRoleDetailComReqDto queryRoleDetailComReqDto_1 = new QueryRoleDetailComReqDto();
        queryRoleDetailComReqDto_1.setRoleCode("PERSON_LIABLE");//CUSTOM_CONVENTION//sourceId:1238624_1

        /*D1-查询角色详情（责任人）[2747]   */

        queryRoleDetailComRespDto_2 = fwBaseRoleClient.queryRoleDetailCom(queryRoleDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤4: 3-2-06新增评价填报角色 - addEvaFillRole
        String string_2 = null;
        if (queryRoleDetailComRespDto_2 != null) {
            OmsEvaluationFillRole omsEvaluationFillRole_1 = new OmsEvaluationFillRole();
            omsEvaluationFillRole_1.setRoleTypeCode("APPLICANT");//sourceId:1238629_1
            omsEvaluationFillRole_1.setIsSystemType("TRUE");//sourceId:1238631_1
            omsEvaluationFillRole_1.setOrderNumber(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1238632_1
            if (queryRoleDetailComRespDto_2 != null) {
                omsEvaluationFillRole_1.setRoleId(queryRoleDetailComRespDto_2.getRoleId());//SimpleFieldAssign//sourceId:1238635_1
                omsEvaluationFillRole_1.setRoleCode(queryRoleDetailComRespDto_2.getRoleCode());//SimpleFieldAssign//sourceId:1238628_1
                omsEvaluationFillRole_1.setRoleName(queryRoleDetailComRespDto_2.getRoleName());//SimpleFieldAssign//sourceId:1238636_1
            }
            if (reqDto != null) {
                omsEvaluationFillRole_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238630_1
                omsEvaluationFillRole_1.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1238637_1
                omsEvaluationFillRole_1.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1238633_1
            }

            /*3-2-06新增填报角色（责任人）[2449]   */
            Assert.isNull(omsEvaluationFillRole_1.getRoleId(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-普通角色ID不能为空", false);
            Assert.isNull(omsEvaluationFillRole_1.getRoleCode(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-普通角色标识不能为空", false);
            Assert.isNull(omsEvaluationFillRole_1.getRoleName(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-普通角色名称不能为空", false);
            Assert.isNull(omsEvaluationFillRole_1.getRoleTypeCode(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-评价填报角色类型编码不能为空", false);
            Assert.isNull(omsEvaluationFillRole_1.getEvaluationTemplateId(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-评价模板ID不能为空", false);
            Assert.isNull(omsEvaluationFillRole_1.getIsSystemType(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-是否系统类型不能为空", false);
            Assert.isNull(omsEvaluationFillRole_1.getOrderNumber(), "D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-排序不能为空", false);
            string_2 = mOmsEvaluationFillRoleService.addEvaFillRole(omsEvaluationFillRole_1)/*vcase invoke 本地 method 方法调用;*/;


        }

//步骤5: D2-3查配置项匹配答案列表(公共)（跨服务） - queryConfItemMatchAnswerListCom
        QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto = null;
        QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto = new QueryConfItemMatchAnswerListComReqDto();
        queryConfItemMatchAnswerListComReqDto.setConfItemCode("EVA_ROLE_SET");//CUSTOM_CONVENTION//sourceId:376018_1
        queryConfItemMatchAnswerListComReqDto.setIsPlatData("TRUE");//sourceId:376021_1
        if (reqDto != null) {
            queryConfItemMatchAnswerListComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:952858_1
        }

        /*D2-3查评价角色配置答案[2505]   */
        Assert.isNull(queryConfItemMatchAnswerListComReqDto.getConfSchemeId(), "D3-2新增评价填报角色(公共)-D2-3查评价角色配置答案-配置方案ID 不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerListComReqDto.getConfItemCode(), "D3-2新增评价填报角色(公共)-D2-3查评价角色配置答案-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerListComReqDto.getIsPlatData(), "D3-2新增评价填报角色(公共)-D2-3查评价角色配置答案-是否标准答案不能为空", false);
        queryConfItemMatchAnswerListComRespDto = confSchemeService.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤6: D1-2查询角色列表ByCodes(公共) - batchQueryRoleListByCodesCom
        BatchQueryRoleListByCodesComRespDto batchQueryRoleListByCodesComRespDto = null;
        if (queryConfItemMatchAnswerListComRespDto != null) {
            BatchQueryRoleListByCodesComReqDto batchQueryRoleListByCodesComReqDto = new BatchQueryRoleListByCodesComReqDto();
            if (queryConfItemMatchAnswerListComRespDto != null && queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList() != null && !CollectionUtil.isEmpty(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList())) {
                batchQueryRoleListByCodesComReqDto.setRoleCodeList(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList().stream().map(item -> item.getEndValue())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:376029_1
            }

            /*D1-2查询角色列表ByCodes(公共)[3223]   */

            batchQueryRoleListByCodesComRespDto = fwBaseRoleClient.batchQueryRoleListByCodesCom(batchQueryRoleListByCodesComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }

//步骤7: 3-2-06批量增评价填报角色 - batchAddEvaFillRole
        boolean bOOLEAN;
        if (batchQueryRoleListByCodesComRespDto != null) {
            List<OmsEvaluationFillRole> listOmsEvaluationFillRole = new ArrayList<>();
            if (batchQueryRoleListByCodesComRespDto != null && batchQueryRoleListByCodesComRespDto.getRoleList() != null && !CollectionUtil.isEmpty(batchQueryRoleListByCodesComRespDto.getRoleList())) {
                listOmsEvaluationFillRole = //objList-to-objLists
                        batchQueryRoleListByCodesComRespDto.getRoleList().stream().map(item -> {
                            OmsEvaluationFillRole elm = new OmsEvaluationFillRole();
                            elm.setRoleTypeCode("VALUATOR");//sourceId:106792_2
                            elm.setIsSystemType("TRUE");//sourceId:106794_2
                            elm.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:106795_2
                            if (item != null) {
                                elm.setRoleId(item.getRoleId());//SimpleFieldAssign//sourceId:106797_2
                                elm.setRoleCode(item.getRoleCode());//SimpleFieldAssign//sourceId:106791_2
                                elm.setRoleName(item.getRoleName());//SimpleFieldAssign//sourceId:106798_2
                            }
                            if (reqDto != null) {
                                elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:106793_2
                                elm.setBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:106796_2
                            }
                            return elm;
                        }).collect(Collectors.toList());//objList-to-objLists//sourceId:376025_1
            }

            /*3-2-06批量增评价角色[3217]   */

            bOOLEAN = mOmsEvaluationFillRoleService.batchAddEvaFillRole(listOmsEvaluationFillRole)/*vcase invoke 本地 method 方法调用;*/;


        }

        AddEvaFillRoleComRespDto retData = new AddEvaFillRoleComRespDto();
        if (string_1 != null) {
            retData.setEvaluationFillRoleId(string_1);//SimpleFieldAssign//sourceId:376038_1
        }


        return retData;
    }

    /**
     * D3-2执行删除模板克隆答案等相关(公共)[4845]
     * gen by moon at 5/14/2023, 2:57:47 AM
     */
    @Trace(operationName = "D3-2执行删除模板克隆答案等相关(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTempCloneResultEtcComRespDto implementTempCloneResultEtcCom(ImplementTempCloneResultEtcComReqDto reqDto) {


        //virtualUsage M3异步开始（特殊方法）  19548
        //ModelCode: asynchronizationStart
        Callable<String> call = new Callable<String>() {

            @Override
            public String call() throws Exception {
                //执行方法
//virtualUsage 3-2-09执行悬停查调度任务（悬停）  39673
                OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch = null;
                ImplementSpinLockCheckTimingTaskReq implementSpinLockCheckTimingTaskReq = new ImplementSpinLockCheckTimingTaskReq();
                if (reqDto != null) {
                    implementSpinLockCheckTimingTaskReq.setTimingTaskDispatchId(reqDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:890349_1_39673
                    implementSpinLockCheckTimingTaskReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:890357_1_39673
                }

                /*3-2-09执行悬停查调度任务（悬停）[4310]   */
                Assert.isNull(implementSpinLockCheckTimingTaskReq.getTimingTaskDispatchId(), "D3-2执行删除模板克隆答案等相关(公共)-3-2-09执行悬停查调度任务（悬停）-定时任务调度记录ID不能为空", false);
                Assert.isNull(implementSpinLockCheckTimingTaskReq.getSpaceId(), "D3-2执行删除模板克隆答案等相关(公共)-3-2-09执行悬停查调度任务（悬停）-创建于空间ID不能为空", false);
                omsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.implementSpinLockCheckTimingTask(implementSpinLockCheckTimingTaskReq)/*vcase invoke 本地 method 方法调用;*/;


                if ((omsTargetTimingTaskDispatch != null && omsTargetTimingTaskDispatch.getTimingTaskDispatchId() == null || omsTargetTimingTaskDispatch != null && omsTargetTimingTaskDispatch.getIsComplete() != null && omsTargetTimingTaskDispatch.getIsComplete().equals("TRUE"))) {
                    //if((3-2-09执行悬停查调度任务（悬停）.定时任务调度记录ID 值等于空  or 3-2-09执行悬停查调度任务（悬停）.是否执行完成 等于 是))  39685

//异常结束 39687
                    throw new BizException("C00028", "对不起，没有数据！！", false);
                }
//virtualUsage M3业务应用公共字段推送内存  39689
                //ModelCode: publicFieldCache
                ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
                if (omsTargetTimingTaskDispatch != null) {
                    ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq = new ImplementBizPublicFieldPushMemoryReqDto();
                    if (omsTargetTimingTaskDispatch != null) {
                        publicFieldCacheReq.setCreateInductionId(omsTargetTimingTaskDispatch.getCreateInductionId());//SimpleFieldAssign//sourceId:890375_1_39689
                        publicFieldCacheReq.setSpaceId(omsTargetTimingTaskDispatch.getSpaceId());//SimpleFieldAssign//sourceId:890376_1_39689
                        publicFieldCacheReq.setAppId(omsTargetTimingTaskDispatch.getAppId());//SimpleFieldAssign//sourceId:890377_1_39689
                    }

                    /*M3业务应用公共字段推送内存[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
                    Assert.isNull(publicFieldCacheReq.getCreateInductionId(), "D3-2执行删除模板克隆答案等相关(公共)-M3业务应用公共字段推送内存-创建人就职记录ID 不能为空", false);
                    Assert.isNull(publicFieldCacheReq.getSpaceId(), "D3-2执行删除模板克隆答案等相关(公共)-M3业务应用公共字段推送内存-创建于空间ID不能为空", false);
                    Assert.isNull(publicFieldCacheReq.getAppId(), "D3-2执行删除模板克隆答案等相关(公共)-M3业务应用公共字段推送内存-创建于联盟应用ID不能为空", false);
                    publicFieldCacheRes = nbEvaTheme.implementBizPublicFieldPushMemory(publicFieldCacheReq);


                }
//virtualUsage D2-3更新删除涉及授权方案信息(公共)  39680
                RefreshDelInvolveAuthorizationSchInfoComRespDto refreshDelInvolveAuthorizationSchInfoComRespDto = null;
                if (omsTargetTimingTaskDispatch != null) {
                    RefreshDelInvolveAuthorizationSchInfoComReqDto refreshDelInvolveAuthorizationSchInfoComReqDto = new RefreshDelInvolveAuthorizationSchInfoComReqDto();
                    if (omsTargetTimingTaskDispatch != null) {
                        refreshDelInvolveAuthorizationSchInfoComReqDto.setConfSchemeId(omsTargetTimingTaskDispatch.getObjectId());//SimpleFieldAssign//sourceId:890400_1_39680
                        refreshDelInvolveAuthorizationSchInfoComReqDto.setEvaluationTemplateId(omsTargetTimingTaskDispatch.getThemeContentId());//SimpleFieldAssign//sourceId:890399_1_39680
                    }

                    /*D2-3更新删除涉及授权方案信息(公共)[4837]   */
                    Assert.isNull(refreshDelInvolveAuthorizationSchInfoComReqDto.getConfSchemeId(), "D3-2执行删除模板克隆答案等相关(公共)-D2-3更新删除涉及授权方案信息(公共)-配置方案ID 不能为空", false);
                    Assert.isNull(refreshDelInvolveAuthorizationSchInfoComReqDto.getEvaluationTemplateId(), "D3-2执行删除模板克隆答案等相关(公共)-D2-3更新删除涉及授权方案信息(公共)-冗余评价模板ID不能为空", false);
                    refreshDelInvolveAuthorizationSchInfoComRespDto = fwCompSchemeOpenRecordClient.refreshDelInvolveAuthorizationSchInfoCom(refreshDelInvolveAuthorizationSchInfoComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
//virtualUsage D2更新评价主题开通记录  39952
                ImplementUpdateSchOpenRecordComRespDto implementUpdateSchOpenRecordComRespDto = null;
                if (omsTargetTimingTaskDispatch != null) {
                    ImplementUpdateSchOpenRecordComReqDto implementUpdateSchOpenRecordComReqDto = new ImplementUpdateSchOpenRecordComReqDto();
                    implementUpdateSchOpenRecordComReqDto.setCustomField1("DEL");//CUSTOM_CONVENTION//sourceId:896045_1_39952
                    if (omsTargetTimingTaskDispatch != null) {
                        implementUpdateSchOpenRecordComReqDto.setConfSchemeId(omsTargetTimingTaskDispatch.getAddRuleInfoId());//SimpleFieldAssign//sourceId:896046_1_39952
                        implementUpdateSchOpenRecordComReqDto.setTenantSpaceId(omsTargetTimingTaskDispatch.getSpaceId());//SimpleFieldAssign//sourceId:896047_1_39952
                    }

                    /*D2更新评价主题开通记录[6468]   */
                    Assert.isNull(implementUpdateSchOpenRecordComReqDto.getConfSchemeId(), "D3-2执行删除模板克隆答案等相关(公共)-D2更新评价主题开通记录-配置方案ID 不能为空", false);
                    Assert.isNull(implementUpdateSchOpenRecordComReqDto.getTenantSpaceId(), "D3-2执行删除模板克隆答案等相关(公共)-D2更新评价主题开通记录-租户空间ID不能为空", false);
                    Assert.isNull(implementUpdateSchOpenRecordComReqDto.getCustomField1(), "D3-2执行删除模板克隆答案等相关(公共)-D2更新评价主题开通记录-更新操作场景不能为空", false);
                    implementUpdateSchOpenRecordComRespDto = fwCompSchemeOpenRecordClient.implementUpdateSchOpenRecordCom(implementUpdateSchOpenRecordComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
//virtualUsage 3-2-09查询定时任务调度详情  26599
                OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch_2 = null;
                QueryTimerTaskPlanDetailReq queryTimerTaskPlanDetailReq = new QueryTimerTaskPlanDetailReq();
                if (reqDto != null) {
                    queryTimerTaskPlanDetailReq.setTimingTaskDispatchId(reqDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:586523_1_26599
                }

                /*3-2-09查询定时任务调度详情[3187]   */
                Assert.isNull(queryTimerTaskPlanDetailReq.getTimingTaskDispatchId(), "D3-2执行删除模板克隆答案等相关(公共)-3-2-09查询定时任务调度详情-定时任务调度记录ID不能为空", false);
                omsTargetTimingTaskDispatch_2 = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanDetail(queryTimerTaskPlanDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                if ((omsTargetTimingTaskDispatch_2 != null && omsTargetTimingTaskDispatch_2.getIsComplete() != null && omsTargetTimingTaskDispatch_2.getIsComplete().equals("FALSE"))) {
                    //if(3-2-09查询定时任务调度详情.是否执行完成 等于 否)  19551

                    boolean bOOLEAN;
                    if (omsTargetTimingTaskDispatch_2 != null) {
                        String string = new String();
                        if (omsTargetTimingTaskDispatch_2 != null) {
                            string = omsTargetTimingTaskDispatch_2.getTimingTaskDispatchId();
                            ;//SimpleFieldAssign//sourceId:378811_1_26600
                        }

                        /*3-2-09删除定时任务调度[3279]   */
                        Assert.isNull(string, "D3-2执行删除模板克隆答案等相关(公共)-3-2-09删除定时任务调度-定时任务调度记录ID不能为空", false);
                        bOOLEAN = mOmsTargetTimingTaskDispatchService.deleteTimerTaskPlan(string)/*vcase invoke 本地 method 方法调用;*/;


                    }
                } else {
                    //else  26602

//异常结束 26603
                    throw new BizException("500", "系统异常，请联系管理员！", false);
                }
//virtualUsage M3异步结束（特殊方法）  19550
                //ModelCode: asynchronizationEnd
                return "";
            }
        };
        CommonFunctionHelper.asynExcute(call);
        ImplementTempCloneResultEtcComRespDto retData = new ImplementTempCloneResultEtcComRespDto();


        return retData;
    }

    /**
     * D3-2检查是否参与评价工作(公共)[3228]
     * gen by moon at 12/31/2022, 5:30:17 PM
     */
    @Trace(operationName = "D3-2检查是否参与评价工作(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public CheckIsOpenEvaComRespDto checkIsOpenEvaCom(CheckIsOpenEvaComReqDto reqDto) {


        AddOutputParametersRespDto receptionServiceRes_1 = null;
        ImplementOutputParametersRespDto receptionServiceRes_3 = null;
//virtualUsage D3执行内容类型互转表类型(公共)  26071
        ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
        ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto = new ImplementContentTypeChangeTableTypeComReqDto();
        if (reqDto != null) {
            implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:559193_1_26071
        }

        /*D3执行内容类型互转表类型(公共)[5354]   */
        Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(), "D3-2检查是否参与评价工作(公共)-D3执行内容类型互转表类型(公共)-关联目标内容类型编码不能为空", false);
        implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto);


//virtualUsage D3判断目标内容是否开启主观评分(公共)  25133
        JudgeTargetContIsOpenCustomReportComRespDto judgeTargetContIsOpenCustomReportComRespDto = null;
        JudgeTargetContIsOpenCustomReportComReqDto judgeTargetContIsOpenCustomReportComReqDto = new JudgeTargetContIsOpenCustomReportComReqDto();
        if (reqDto != null) {
            judgeTargetContIsOpenCustomReportComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:514393_1_25133
            judgeTargetContIsOpenCustomReportComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:514392_1_25133
            judgeTargetContIsOpenCustomReportComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:514394_1_25133
        }

        /*D3判断目标内容是否开启主观评分(公共)[5008]   */
        Assert.isNull(judgeTargetContIsOpenCustomReportComReqDto.getTargetCycleContentTypeCode(), "D3-2检查是否参与评价工作(公共)-D3判断目标内容是否开启主观评分(公共)-关联目标内容类型编码不能为空", false);
        Assert.isNull(judgeTargetContIsOpenCustomReportComReqDto.getTargetCycleContentId(), "D3-2检查是否参与评价工作(公共)-D3判断目标内容是否开启主观评分(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(judgeTargetContIsOpenCustomReportComReqDto.getEvaluationTemplateId(), "D3-2检查是否参与评价工作(公共)-D3判断目标内容是否开启主观评分(公共)-冗余评价模板ID不能为空", false);
        judgeTargetContIsOpenCustomReportComRespDto = indexSystemService.judgeTargetContIsOpenCustomReportCom(judgeTargetContIsOpenCustomReportComReqDto);


//virtualUsage 3-6-02查虚拟组织成员列表  6666
        List<OmsVirtualOrgMember> listOmsVirtualOrgMember = new ArrayList<>();
        if (implementContentTypeChangeTableTypeComRespDto != null) {
            QueryVirtualOrgMemberListReq queryVirtualOrgMemberListReq = new QueryVirtualOrgMemberListReq();
            queryVirtualOrgMemberListReq.setVirtualOrgInductionRecordId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:122747_1_6666
            queryVirtualOrgMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:122742_1_6666
            if (reqDto != null) {
                queryVirtualOrgMemberListReq.setEntityId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:122750_1_6666
            }
            if (implementContentTypeChangeTableTypeComRespDto != null) {
                queryVirtualOrgMemberListReq.setTableTypeCode(implementContentTypeChangeTableTypeComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:122741_1_6666
            }

            /*3-6-02查虚拟组织成员列表[2201]   */
            Assert.isNull(queryVirtualOrgMemberListReq.getEntityId(), "D3-2检查是否参与评价工作(公共)-3-6-02查虚拟组织成员列表-冗余内容表主键ID不能为空", false);
            Assert.isNull(queryVirtualOrgMemberListReq.getTableTypeCode(), "D3-2检查是否参与评价工作(公共)-3-6-02查虚拟组织成员列表-冗余内容表类型编码不能为空", false);
            Assert.isNull(queryVirtualOrgMemberListReq.getVirtualOrgInductionRecordId(), "D3-2检查是否参与评价工作(公共)-3-6-02查虚拟组织成员列表-虚拟组织成员就职记录ID不能为空", false);
            Assert.isNull(queryVirtualOrgMemberListReq.getSubjectLifeCycle(), "D3-2检查是否参与评价工作(公共)-3-6-02查虚拟组织成员列表-主体生命周期不能为空", false);
            listOmsVirtualOrgMember = mOmsVirtualOrgMemberService.queryVirtualOrgMemberList(queryVirtualOrgMemberListReq);


        }
//virtualUsage 3-2-06查询评价填报角色列表ByCodes  6667
        List<OmsEvaluationFillRole> listOmsEvaluationFillRole = new ArrayList<>();
        if (listOmsVirtualOrgMember != null && !CollectionUtil.isEmpty(listOmsVirtualOrgMember) && listOmsVirtualOrgMember.size() > 0) {
            BatchQueryEvaFillRoleListByCodesReq batchQueryEvaFillRoleListByCodesReq = new BatchQueryEvaFillRoleListByCodesReq();
            batchQueryEvaFillRoleListByCodesReq.setEvaFillRoleList(listOmsVirtualOrgMember.stream().map(item -> item.getRoleCode())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:122734_1_6667
            if (reqDto != null) {
                batchQueryEvaFillRoleListByCodesReq.setRoleTypeCode(reqDto.getRoleTypeCode());//SimpleFieldAssign//sourceId:122737_1_6667
                batchQueryEvaFillRoleListByCodesReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:122735_1_6667
            }

            /*3-2-06查询评价填报角色列表ByCodes[3230]   */
            Assert.isNull(batchQueryEvaFillRoleListByCodesReq.getRoleTypeCode(), "D3-2检查是否参与评价工作(公共)-3-2-06查询评价填报角色列表ByCodes-评价填报角色类型编码不能为空", false);
            Assert.isNull(batchQueryEvaFillRoleListByCodesReq.getEvaluationTemplateId(), "D3-2检查是否参与评价工作(公共)-3-2-06查询评价填报角色列表ByCodes-评价模板ID不能为空", false);
            listOmsEvaluationFillRole = mOmsEvaluationFillRoleService.batchQueryEvaFillRoleListByCodes(batchQueryEvaFillRoleListByCodesReq);


        }
        if ((judgeTargetContIsOpenCustomReportComRespDto != null && judgeTargetContIsOpenCustomReportComRespDto.getIsSubjectiveScoring() != null && judgeTargetContIsOpenCustomReportComRespDto.getIsSubjectiveScoring().equals("TRUE") && listOmsEvaluationFillRole != null && listOmsEvaluationFillRole != null && listOmsEvaluationFillRole.size() > 0)) {
            //if((D3判断目标内容是否开启主观评分(公共).是否开启主观评分 等于 是 and 3-2-06查询评价填报角色列表ByCodes.评价填报角色列表数据集条数 大于 0))  6668

//ModelCode: receptionService
            AddOutputParametersRespDto receptionServiceRes = null;
            AddOutputParametersReqDto receptionServiceReq = new AddOutputParametersReqDto();
            receptionServiceReq.setIsOpenEvaWork("TRUE");//sourceId:312650_1_6669

            /*模板开启评价工作[2888] 第一个分支返回：TRUE，第二个分支返回：FALSE 用于特殊方法接收上游入参。 */

            receptionServiceRes = nbEvaTheme.addOutputParameters(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
//processBranchName:正常结束 ,processBranchId:15911

        } else {
            //else  6670

//ModelCode: receptionService
            ImplementOutputParametersRespDto receptionServiceRes_2 = null;
            ImplementOutputParametersReqDto receptionServiceReq_1 = new ImplementOutputParametersReqDto();
            receptionServiceReq_1.setIsOpenEvaWork("FALSE");//sourceId:312658_1_15910

            /*模板未开启评价工作[2888]  用于特殊方法接收上游入参。 */

            receptionServiceRes_2 = nbEvaTheme.implementOutputParameters(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
//processBranchName:正常结束 ,processBranchId:15912

        }
        CheckIsOpenEvaComRespDto retData = new CheckIsOpenEvaComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setIsOpenEvaWork(receptionServiceRes_1.getIsOpenEvaWork());//SimpleFieldAssign//sourceId:123055_1
        }
        if (receptionServiceRes_3 != null) {
            retData.setIsOpenEvaWork(receptionServiceRes_3.getIsOpenEvaWork());//SimpleFieldAssign//sourceId:123055_1
        }


        return retData;
    }

    /**
     * D3-2查询评价填报角色详情(公共)[3333]
     * gen by moon at 12/16/2022, 9:08:00 PM
     */
    @Trace(operationName = "D3-2查询评价填报角色详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaFillRoleDetailComRespDto queryEvaFillRoleDetailCom(QueryEvaFillRoleDetailComReqDto reqDto) {


        OmsEvaluationFillRole omsEvaluationFillRole_1 = null;
//步骤0: 3-2-06查评价填报角色详情 - queryEvaFillRoleDetail
        OmsEvaluationFillRole omsEvaluationFillRole = null;
        QueryEvaFillRoleDetailReq queryEvaFillRoleDetailReq = new QueryEvaFillRoleDetailReq();
        if (reqDto != null) {
            queryEvaFillRoleDetailReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:131347_1
            queryEvaFillRoleDetailReq.setRoleTypeCode(reqDto.getRoleTypeCode());//SimpleFieldAssign//sourceId:131348_1
            queryEvaFillRoleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:131349_1
            queryEvaFillRoleDetailReq.setIsSystemType(reqDto.getIsSystemType());//SimpleFieldAssign//sourceId:131350_1
            queryEvaFillRoleDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:131351_1
        }

        /*3-2-06查评价填报角色详情[2380]   */

        omsEvaluationFillRole = mOmsEvaluationFillRoleService.queryEvaFillRoleDetail(queryEvaFillRoleDetailReq);


        omsEvaluationFillRole_1 = omsEvaluationFillRole;

        QueryEvaFillRoleDetailComRespDto retData = new QueryEvaFillRoleDetailComRespDto();
        if (omsEvaluationFillRole_1 != null) {
            retData.setEvaluationFillRoleId(omsEvaluationFillRole_1.getEvaluationFillRoleId());//SimpleFieldAssign//sourceId:131383_1
            retData.setRoleId(omsEvaluationFillRole_1.getRoleId());//SimpleFieldAssign//sourceId:520844_1
            retData.setRoleCode(omsEvaluationFillRole_1.getRoleCode());//SimpleFieldAssign//sourceId:520847_1
            retData.setRoleName(omsEvaluationFillRole_1.getRoleName());//SimpleFieldAssign//sourceId:520850_1
        }


        return retData;
    }

    /**
     * D3执行高层人工设置完成[5542]
     * gen by moon at 11/24/2023, 10:36:01 PM
     */
    @Trace(operationName = "D3执行高层人工设置完成")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementMidManualSetCompletRespDto implementMidManualSetComplet(ImplementMidManualSetCompletReqDto reqDto) {


        //virtualUsage 3-3-05查询是否有下发指标  25871
        List<OmsTargetObjectivePlanExtend> listOmsTargetObjectivePlanExtend = new ArrayList<>();
        QueryTargetObjPlanExListReq queryTargetObjPlanExListReq = new QueryTargetObjPlanExListReq();
        queryTargetObjPlanExListReq.setIsFirstObjective("TRUE");//sourceId:551759_1_25871
        queryTargetObjPlanExListReq.setIsArchive("FALSE");//sourceId:551761_1_25871
        if (reqDto != null) {
            queryTargetObjPlanExListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:551755_1_25871
        }

        /*3-3-05查询是否有下发指标[3650]   */
        Assert.isNull(queryTargetObjPlanExListReq.getIsFirstObjective(), "D3执行高层人工设置完成-3-3-05查询是否有下发指标-是否目标下发不能为空", false);
        Assert.isNull(queryTargetObjPlanExListReq.getEvaluationTemplateId(), "D3执行高层人工设置完成-3-3-05查询是否有下发指标-冗余评价模板ID不能为空", false);
        Assert.isNull(queryTargetObjPlanExListReq.getIsArchive(), "D3执行高层人工设置完成-3-3-05查询是否有下发指标-是否存档不能为空", false);
        listOmsTargetObjectivePlanExtend = mOmsTargetObjectivePlanExtendService.queryTargetObjPlanExList(queryTargetObjPlanExListReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 3-11-01查评价模板级别目标的完成状态  25878
        OmsAssistNodeStatus omsAssistNodeStatus = null;
        QueryAssistNodeStatusDetailReq queryAssistNodeStatusDetailReq = new QueryAssistNodeStatusDetailReq();
        queryAssistNodeStatusDetailReq.setAssistNodeTypeCode("OMS_TARGET");//sourceId:551684_1_25878
        queryAssistNodeStatusDetailReq.setObjectTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:551703_1_25878
        if (reqDto != null) {
            queryAssistNodeStatusDetailReq.setAssistNodeTypeObjectId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:551685_1_25878
            queryAssistNodeStatusDetailReq.setObjectId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:551704_1_25878
        }

        /*3-11-01查评价模板级别目标的完成状态[317]   */
        Assert.isNull(queryAssistNodeStatusDetailReq.getAssistNodeTypeObjectId(), "D3执行高层人工设置完成-3-11-01查评价模板级别目标的完成状态-节点内容对象实例ID不能为空", false);
        Assert.isNull(queryAssistNodeStatusDetailReq.getAssistNodeTypeCode(), "D3执行高层人工设置完成-3-11-01查评价模板级别目标的完成状态-节点内容对象类型编码不能为空", false);
        Assert.isNull(queryAssistNodeStatusDetailReq.getObjectTypeCode(), "D3执行高层人工设置完成-3-11-01查评价模板级别目标的完成状态-归属对象类型编码不能为空", false);
        Assert.isNull(queryAssistNodeStatusDetailReq.getObjectId(), "D3执行高层人工设置完成-3-11-01查评价模板级别目标的完成状态-归属对象内容ID不能为空", false);
        omsAssistNodeStatus = mOmsAssistNodeStatusService.queryAssistNodeStatusDetail(queryAssistNodeStatusDetailReq)/*vcase invoke 本地 method 方法调用;*/;
        Assert.isTrue(omsAssistNodeStatus == null || omsAssistNodeStatus.getIsComplete() == null, "找不到数据，系统异常", false);


//virtualUsage 3-3-09-03查询评价模板批次设置详情  25879
        OmsEvaBatchRelatedSet omsEvaBatchRelatedSet = null;
        QueryPlanEvaBatchSetDetailReq queryPlanEvaBatchSetDetailReq = new QueryPlanEvaBatchSetDetailReq();
        queryPlanEvaBatchSetDetailReq.setBatchSetObjectType("TOP_EVA_TEMP_MGT");//sourceId:551646_1_25879
        queryPlanEvaBatchSetDetailReq.setCurrentManageObjectType("TOP");//sourceId:551656_1_25879
        queryPlanEvaBatchSetDetailReq.setManageLockStatus("UNLOCK");//sourceId:551762_1_25879
        if (reqDto != null) {
            queryPlanEvaBatchSetDetailReq.setBatchSetId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:551645_1_25879
        }

        /*3-3-09-03查询评价模板批次设置详情[2998]   */
        Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetId(), "D3执行高层人工设置完成-3-3-09-03查询评价模板批次设置详情-批次设置对象ID不能为空", false);
        Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetObjectType(), "D3执行高层人工设置完成-3-3-09-03查询评价模板批次设置详情-批次设置对象类型不能为空", false);
        Assert.isNull(queryPlanEvaBatchSetDetailReq.getCurrentManageObjectType(), "D3执行高层人工设置完成-3-3-09-03查询评价模板批次设置详情-当前管理对象类型不能为空", false);
        Assert.isNull(queryPlanEvaBatchSetDetailReq.getManageLockStatus(), "D3执行高层人工设置完成-3-3-09-03查询评价模板批次设置详情-管理锁定状态不能为空", false);
        omsEvaBatchRelatedSet = mOmsEvaBatchRelatedSetService.queryPlanEvaBatchSetDetail(queryPlanEvaBatchSetDetailReq)/*vcase invoke 本地 method 方法调用;*/;
        Assert.isTrue(omsEvaBatchRelatedSet == null || omsEvaBatchRelatedSet.getBatchRelatedSetId() == null || omsEvaBatchRelatedSet == null || omsEvaBatchRelatedSet.getSetCompleteStatus() == null, "找不到数据，系统异常", false);


        if ((listOmsTargetObjectivePlanExtend != null && listOmsTargetObjectivePlanExtend != null && listOmsTargetObjectivePlanExtend.size() == 0 && reqDto != null && reqDto.getSetCompleteStatus() != null && reqDto.getSetCompleteStatus().equals("TRUE"))) {
            //if((3-3-05查询是否有下发指标.指标扩展规划设置列表数据集条数 等于 0 and D3执行高层人工设置完成.设置完成状态 等于 是))  25880

            List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch = new ArrayList<>();
            QueryTimerTaskPlanListReq queryTimerTaskPlanListReq = new QueryTimerTaskPlanListReq();
            queryTimerTaskPlanListReq.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:551730_1_25882
            queryTimerTaskPlanListReq.setIsAppointSimpleMq("TRUE");//sourceId:551732_1_25882
            queryTimerTaskPlanListReq.setIsComplete("FALSE");//sourceId:551736_1_25882
            queryTimerTaskPlanListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:551733_1_25882
            if (reqDto != null) {
                queryTimerTaskPlanListReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:551731_1_25882
            }

            /*3-2-09查询指标下发前MQ队列定时任务调度列表[3261]   */
            Assert.isNull(queryTimerTaskPlanListReq.getThemeContentId(), "D3执行高层人工设置完成-3-2-09查询指标下发前MQ队列定时任务调度列表-主题内容ID不能为空", false);
            Assert.isNull(queryTimerTaskPlanListReq.getThemeContentTypeCode(), "D3执行高层人工设置完成-3-2-09查询指标下发前MQ队列定时任务调度列表-主题内容类型编码不能为空", false);
            Assert.isNull(queryTimerTaskPlanListReq.getIsAppointSimpleMq(), "D3执行高层人工设置完成-3-2-09查询指标下发前MQ队列定时任务调度列表-是否固化消息队列不能为空", false);
            Assert.isNull(queryTimerTaskPlanListReq.getIsComplete(), "D3执行高层人工设置完成-3-2-09查询指标下发前MQ队列定时任务调度列表-是否执行完成不能为空", false);
            Assert.isNull(queryTimerTaskPlanListReq.getSpaceId(), "D3执行高层人工设置完成-3-2-09查询指标下发前MQ队列定时任务调度列表-创建于空间ID不能为空", false);
            listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanList(queryTimerTaskPlanListReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((omsAssistNodeStatus != null && omsAssistNodeStatus.getIsComplete() != null && omsAssistNodeStatus.getIsComplete().equals("TRUE") && omsEvaBatchRelatedSet != null && omsEvaBatchRelatedSet.getSetCompleteStatus() != null && omsEvaBatchRelatedSet.getSetCompleteStatus().equals("FALSE") && listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch.size() == 0)) {
                //if((3-11-01查评价模板级别目标的完成状态.是否已完成 等于 是 and 3-3-09-03查询评价模板批次设置详情.设置完成状态 等于 否 and 3-2-09查询指标下发前MQ队列定时任务调度列表.定时任务调度列表数据集条数 等于 0))  25885

                boolean bOOLEAN;
                if (omsEvaBatchRelatedSet != null) {
                    OmsEvaBatchRelatedSet omsEvaBatchRelatedSet_2 = new OmsEvaBatchRelatedSet();
                    omsEvaBatchRelatedSet_2.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:551764_1_25886
                    omsEvaBatchRelatedSet_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:551765_1_25886
                    if (omsEvaBatchRelatedSet != null) {
                        omsEvaBatchRelatedSet_2.setBatchRelatedSetId(omsEvaBatchRelatedSet.getBatchRelatedSetId());//SimpleFieldAssign//sourceId:551763_1_25886
                    }
                    if (reqDto != null) {
                        omsEvaBatchRelatedSet_2.setSetCompleteStatus(reqDto.getSetCompleteStatus());//SimpleFieldAssign//sourceId:551767_1_25886
                    }

                    /*3-3-09-03修改评价模板批次设置[3034]   */
                    Assert.isNull(omsEvaBatchRelatedSet_2.getBatchRelatedSetId(), "D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-批次相关设置ID不能为空", false);
                    Assert.isNull(omsEvaBatchRelatedSet_2.getSetCompleteStatus(), "D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-设置完成状态不能为空", false);
                    Assert.isNull(omsEvaBatchRelatedSet_2.getOperationInductionId(), "D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-操作人就职记录ID不能为空", false);
                    Assert.isNull(omsEvaBatchRelatedSet_2.getOperateTime(), "D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-操作时间不能为空", false);
                    bOOLEAN = mOmsEvaBatchRelatedSetService.updatePlanEvaBatchSet(omsEvaBatchRelatedSet_2)/*vcase invoke 本地 method 方法调用;*/;


                }
            } else if ((listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch.size() > 0)) {
                //elseif(3-2-09查询指标下发前MQ队列定时任务调度列表.定时任务调度列表数据集条数 大于 0)  25888

//异常结束 25889
                throw new BizException("330000166", "对不起，当前规划还有设置在自动执行，请耐心等待~。", false);
            }
        } else if ((listOmsTargetObjectivePlanExtend != null && listOmsTargetObjectivePlanExtend != null && listOmsTargetObjectivePlanExtend.size() > 0 && reqDto != null && reqDto.getSetCompleteStatus() != null && reqDto.getSetCompleteStatus().equals("TRUE"))) {
            //elseif((3-3-05查询是否有下发指标.指标扩展规划设置列表数据集条数 大于 0 and D3执行高层人工设置完成.设置完成状态 等于 是))  25881

            if ((omsAssistNodeStatus != null && omsAssistNodeStatus.getIsComplete() != null && omsAssistNodeStatus.getIsComplete().equals("TRUE") && omsEvaBatchRelatedSet != null && omsEvaBatchRelatedSet.getSetCompleteStatus() != null && omsEvaBatchRelatedSet.getSetCompleteStatus().equals("FALSE"))) {
                //if((3-11-01查评价模板级别目标的完成状态.是否已完成 等于 是 and 3-3-09-03查询评价模板批次设置详情.设置完成状态 等于 否))  25884

                boolean bOOLEAN_1;
                if (omsEvaBatchRelatedSet != null) {
                    OmsEvaBatchRelatedSet omsEvaBatchRelatedSet_3 = new OmsEvaBatchRelatedSet();
                    omsEvaBatchRelatedSet_3.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:551764_1_25887
                    omsEvaBatchRelatedSet_3.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:551765_1_25887
                    if (omsEvaBatchRelatedSet != null) {
                        omsEvaBatchRelatedSet_3.setBatchRelatedSetId(omsEvaBatchRelatedSet.getBatchRelatedSetId());//SimpleFieldAssign//sourceId:551763_1_25887
                    }
                    if (reqDto != null) {
                        omsEvaBatchRelatedSet_3.setSetCompleteStatus(reqDto.getSetCompleteStatus());//SimpleFieldAssign//sourceId:551767_1_25887
                    }

                    /*3-3-09-03修改评价模板批次设置[3034]   */
                    Assert.isNull(omsEvaBatchRelatedSet_3.getBatchRelatedSetId(), "D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-批次相关设置ID不能为空", false);
                    Assert.isNull(omsEvaBatchRelatedSet_3.getSetCompleteStatus(), "D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-设置完成状态不能为空", false);
                    Assert.isNull(omsEvaBatchRelatedSet_3.getOperationInductionId(), "D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-操作人就职记录ID不能为空", false);
                    Assert.isNull(omsEvaBatchRelatedSet_3.getOperateTime(), "D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-操作时间不能为空", false);
                    bOOLEAN_1 = mOmsEvaBatchRelatedSetService.updatePlanEvaBatchSet(omsEvaBatchRelatedSet_3)/*vcase invoke 本地 method 方法调用;*/;


                }
            }
        } else if ((omsEvaBatchRelatedSet != null && omsEvaBatchRelatedSet.getSetCompleteStatus() != null && omsEvaBatchRelatedSet.getSetCompleteStatus().equals("TRUE") && reqDto != null && reqDto.getSetCompleteStatus() != null && reqDto.getSetCompleteStatus().equals("FALSE"))) {
            //elseif((3-3-09-03查询评价模板批次设置详情.设置完成状态 等于 是 and D3执行高层人工设置完成.设置完成状态 等于 否))  25890

            boolean bOOLEAN_2;
            if (omsEvaBatchRelatedSet != null) {
                OmsEvaBatchRelatedSet omsEvaBatchRelatedSet_4 = new OmsEvaBatchRelatedSet();
                omsEvaBatchRelatedSet_4.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:551764_1_25891
                omsEvaBatchRelatedSet_4.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:551765_1_25891
                if (omsEvaBatchRelatedSet != null) {
                    omsEvaBatchRelatedSet_4.setBatchRelatedSetId(omsEvaBatchRelatedSet.getBatchRelatedSetId());//SimpleFieldAssign//sourceId:551763_1_25891
                }
                if (reqDto != null) {
                    omsEvaBatchRelatedSet_4.setSetCompleteStatus(reqDto.getSetCompleteStatus());//SimpleFieldAssign//sourceId:551767_1_25891
                }

                /*3-3-09-03修改评价模板批次设置[3034]   */
                Assert.isNull(omsEvaBatchRelatedSet_4.getBatchRelatedSetId(), "D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-批次相关设置ID不能为空", false);
                Assert.isNull(omsEvaBatchRelatedSet_4.getSetCompleteStatus(), "D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-设置完成状态不能为空", false);
                Assert.isNull(omsEvaBatchRelatedSet_4.getOperationInductionId(), "D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-操作人就职记录ID不能为空", false);
                Assert.isNull(omsEvaBatchRelatedSet_4.getOperateTime(), "D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-操作时间不能为空", false);
                bOOLEAN_2 = mOmsEvaBatchRelatedSetService.updatePlanEvaBatchSet(omsEvaBatchRelatedSet_4)/*vcase invoke 本地 method 方法调用;*/;


            }
            if ((omsAssistNodeStatus != null && omsAssistNodeStatus.getIsComplete() != null && omsAssistNodeStatus.getIsComplete().equals("FALSE"))) {
                //if(3-11-01查评价模板级别目标的完成状态.是否已完成 等于 否)  54596

                boolean bOOLEAN_3;
                if (omsAssistNodeStatus != null) {
                    OmsAssistNodeStatus omsAssistNodeStatus_2 = new OmsAssistNodeStatus();
                    omsAssistNodeStatus_2.setIsComplete("TRUE");//sourceId:1350854_1_54597
                    omsAssistNodeStatus_2.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1350855_1_54597
                    omsAssistNodeStatus_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1350856_1_54597
                    if (omsAssistNodeStatus != null) {
                        omsAssistNodeStatus_2.setAssistNodeStatusId(omsAssistNodeStatus.getAssistNodeStatusId());//SimpleFieldAssign//sourceId:1350853_1_54597
                    }

                    /*3-11-01修改内容节点状态[315]   */
                    Assert.isNull(omsAssistNodeStatus_2.getAssistNodeStatusId(), "D3执行高层人工设置完成-3-11-01修改内容节点状态-内容节点状态ID不能为空", false);
                    Assert.isNull(omsAssistNodeStatus_2.getIsComplete(), "D3执行高层人工设置完成-3-11-01修改内容节点状态-是否已完成不能为空", false);
                    Assert.isNull(omsAssistNodeStatus_2.getOperationInductionId(), "D3执行高层人工设置完成-3-11-01修改内容节点状态-操作人就职记录ID不能为空", false);
                    Assert.isNull(omsAssistNodeStatus_2.getOperateTime(), "D3执行高层人工设置完成-3-11-01修改内容节点状态-操作时间不能为空", false);
                    bOOLEAN_3 = mOmsAssistNodeStatusService.updateAssistNodeStatus(omsAssistNodeStatus_2)/*vcase invoke 本地 method 方法调用;*/;


                }
            }
        }
        ImplementMidManualSetCompletRespDto retData = new ImplementMidManualSetCompletRespDto();


        return retData;
    }

    /**
     * D3查询评价主题列表(公共)[5717]
     * gen by moon at 1/27/2023, 8:24:44 PM
     */
    @Trace(operationName = "D3查询评价主题列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaThemeListComRespDto queryEvaThemeListCom(QueryEvaThemeListComReqDto reqDto) {


        List<OmsEvaluationSubject> listOmsEvaluationSubject_1 = new ArrayList<>();
        //步骤0: 3-2-01查评价主题列表 - queryEvaThemeList
        List<OmsEvaluationSubject> listOmsEvaluationSubject = new ArrayList<>();
        QueryEvaThemeListReq queryEvaThemeListReq = new QueryEvaThemeListReq();
        queryEvaThemeListReq.setAscriptionSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:613099_1
        if (reqDto != null) {
            queryEvaThemeListReq.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:613110_1
            queryEvaThemeListReq.setConfSchemeCode(reqDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:613111_1
            queryEvaThemeListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:613100_1
        }

        /*3-2-01查评价主题列表[2278]   */
        Assert.isNull(queryEvaThemeListReq.getSubjectLifeCycle(), "D3查询评价主题列表(公共)-3-2-01查评价主题列表-主体生命周期不能为空", false);
        Assert.isNull(queryEvaThemeListReq.getAscriptionSpaceId(), "D3查询评价主题列表(公共)-3-2-01查评价主题列表-归属空间ID不能为空", false);
        listOmsEvaluationSubject = mOmsEvaluationSubjectService.queryEvaThemeList(queryEvaThemeListReq);


        listOmsEvaluationSubject_1 = listOmsEvaluationSubject;

        QueryEvaThemeListComRespDto retData = new QueryEvaThemeListComRespDto();
        retData.setEvalThemeList(listOmsEvaluationSubject_1.stream().map(item -> item.getEvaluationSubjectId())
                .collect(Collectors.toList()));/*list-to-strings*///sourceId:637665_1


        return retData;
    }

    /**
     * D3查询评价模板当前特权管理状态[5856]
     * gen by moon at 2/6/2023, 7:27:59 PM
     */
    @Trace(operationName = "D3查询评价模板当前特权管理状态")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaTempPresentIsSuperMgtStateDetailRespDto queryEvaTempPresentIsSuperMgtStateDetail(QueryEvaTempPresentIsSuperMgtStateDetailReqDto reqDto) {


        ImplementAccessParameterBizFieldRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getBatchOperateScene() != null && reqDto.getBatchOperateScene().equals("TOP"))) {
            //if(D3查询评价模板当前超级管理状态.高/中/基层操作场景 等于 高层)  28990

            OmsEvaBatchRelatedSet omsEvaBatchRelatedSet = null;
            QueryPlanEvaBatchSetDetailReq queryPlanEvaBatchSetDetailReq = new QueryPlanEvaBatchSetDetailReq();
            queryPlanEvaBatchSetDetailReq.setBatchSetObjectType("TOP_EVA_TEMP_MGT");//sourceId:654429_1_28994
            if (reqDto != null) {
                queryPlanEvaBatchSetDetailReq.setBatchSetId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:654428_1_28994
            }

            /*3-3-09-03查询高层评价模板批次设置[2998]   */
            Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetId(), "D3查询评价模板当前特权管理状态-3-3-09-03查询高层评价模板批次设置-批次设置对象ID不能为空", false);
            Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetObjectType(), "D3查询评价模板当前特权管理状态-3-3-09-03查询高层评价模板批次设置-批次设置对象类型不能为空", false);
            omsEvaBatchRelatedSet = mOmsEvaBatchRelatedSetService.queryPlanEvaBatchSetDetail(queryPlanEvaBatchSetDetailReq);
            Assert.isTrue(omsEvaBatchRelatedSet == null || omsEvaBatchRelatedSet.getBatchRelatedSetId() == null, "找不到数据，系统异常", false);


//ModelCode: receptionService
            ImplementAccessParameterBizFieldRespDto receptionServiceRes = null;
            if (omsEvaBatchRelatedSet != null) {
                ImplementAccessParameterBizFieldReqDto receptionServiceReq = new ImplementAccessParameterBizFieldReqDto();
                if (omsEvaBatchRelatedSet != null) {
                    receptionServiceReq.setMgtType(omsEvaBatchRelatedSet.getMgtType());//SimpleFieldAssign//sourceId:655228_1_28997
                    // receptionServiceReq.setIsSuperMgt(omsEvaBatchRelatedSet.getIsSuperMgt());//SimpleFieldAssign//sourceId:655220_1_28997
                }

                /*M3接收上文出参参数[5797]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getMgtType(), "D3查询评价模板当前特权管理状态-M3接收上文出参参数-管理类型不能为空", false);
                Assert.isNull(receptionServiceReq.getIsSuperMgt(), "D3查询评价模板当前特权管理状态-M3接收上文出参参数-是否超级管理不能为空", false);
                receptionServiceRes = nbEvaTheme.implementAccessParameterBizField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((reqDto != null && reqDto.getBatchOperateScene() != null && reqDto.getBatchOperateScene().equals("MID"))) {
            //elseif(D3查询评价模板当前超级管理状态.高/中/基层操作场景 等于 中层)  28991

            OmsEvaBatchRelatedSet omsEvaBatchRelatedSet_2 = null;
            QueryPlanEvaBatchSetDetailReq queryPlanEvaBatchSetDetailReq_1 = new QueryPlanEvaBatchSetDetailReq();
            queryPlanEvaBatchSetDetailReq_1.setBatchSetObjectType("MID_DIV_MGT");//sourceId:654633_1_28995
            if (reqDto != null) {
                queryPlanEvaBatchSetDetailReq_1.setBatchSetId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:654632_1_28995
            }

            /*3-3-09-03查询中层评价模板批次设置[2998]   */
            Assert.isNull(queryPlanEvaBatchSetDetailReq_1.getBatchSetId(), "D3查询评价模板当前特权管理状态-3-3-09-03查询中层评价模板批次设置-批次设置对象ID不能为空", false);
            Assert.isNull(queryPlanEvaBatchSetDetailReq_1.getBatchSetObjectType(), "D3查询评价模板当前特权管理状态-3-3-09-03查询中层评价模板批次设置-批次设置对象类型不能为空", false);
            omsEvaBatchRelatedSet_2 = mOmsEvaBatchRelatedSetService.queryPlanEvaBatchSetDetail(queryPlanEvaBatchSetDetailReq_1);
            Assert.isTrue(omsEvaBatchRelatedSet_2 == null || omsEvaBatchRelatedSet_2.getBatchRelatedSetId() == null, "找不到数据，系统异常", false);


//ModelCode: receptionService
            ImplementAccessParameterBizFieldRespDto receptionServiceRes_2 = null;
            if (omsEvaBatchRelatedSet_2 != null) {
                ImplementAccessParameterBizFieldReqDto receptionServiceReq_1 = new ImplementAccessParameterBizFieldReqDto();
                if (omsEvaBatchRelatedSet_2 != null) {
                    receptionServiceReq_1.setMgtType(omsEvaBatchRelatedSet_2.getMgtType());//SimpleFieldAssign//sourceId:655228_1_28998
//receptionServiceReq_1.setIsSuperMgt(omsEvaBatchRelatedSet_2.getIsSuperMgt());//SimpleFieldAssign//sourceId:655220_1_28998
                }

                /*M3接收上文出参参数[5797]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getMgtType(), "D3查询评价模板当前特权管理状态-M3接收上文出参参数-管理类型不能为空", false);
                Assert.isNull(receptionServiceReq_1.getIsSuperMgt(), "D3查询评价模板当前特权管理状态-M3接收上文出参参数-是否超级管理不能为空", false);
                receptionServiceRes_2 = nbEvaTheme.implementAccessParameterBizField(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        } else if ((reqDto != null && reqDto.getBatchOperateScene() != null && reqDto.getBatchOperateScene().equals("BASIC"))) {
            //elseif(D3查询评价模板当前超级管理状态.高/中/基层操作场景 等于 基层)  28992

            OmsEvaBatchRelatedSet omsEvaBatchRelatedSet_4 = null;
            QueryPlanEvaBatchSetDetailReq queryPlanEvaBatchSetDetailReq_2 = new QueryPlanEvaBatchSetDetailReq();
            queryPlanEvaBatchSetDetailReq_2.setBatchSetObjectType("BASIC_DIV_MGT");//sourceId:655227_1_28999
            if (reqDto != null) {
                queryPlanEvaBatchSetDetailReq_2.setBatchSetId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:655226_1_28999
            }

            /*3-3-09-03查询中层评价模板批次设置[2998]   */
            Assert.isNull(queryPlanEvaBatchSetDetailReq_2.getBatchSetId(), "D3查询评价模板当前特权管理状态-3-3-09-03查询中层评价模板批次设置-批次设置对象ID不能为空", false);
            Assert.isNull(queryPlanEvaBatchSetDetailReq_2.getBatchSetObjectType(), "D3查询评价模板当前特权管理状态-3-3-09-03查询中层评价模板批次设置-批次设置对象类型不能为空", false);
            omsEvaBatchRelatedSet_4 = mOmsEvaBatchRelatedSetService.queryPlanEvaBatchSetDetail(queryPlanEvaBatchSetDetailReq_2);
            Assert.isTrue(omsEvaBatchRelatedSet_4 == null || omsEvaBatchRelatedSet_4.getBatchRelatedSetId() == null, "找不到数据，系统异常", false);


//ModelCode: receptionService
            ImplementAccessParameterBizFieldRespDto receptionServiceRes_3 = null;
            if (omsEvaBatchRelatedSet_4 != null) {
                ImplementAccessParameterBizFieldReqDto receptionServiceReq_2 = new ImplementAccessParameterBizFieldReqDto();
                if (omsEvaBatchRelatedSet_4 != null) {
                    receptionServiceReq_2.setMgtType(omsEvaBatchRelatedSet_4.getMgtType());//SimpleFieldAssign//sourceId:655228_1_28996
//receptionServiceReq_2.setIsSuperMgt(omsEvaBatchRelatedSet_4.getIsSuperMgt());//SimpleFieldAssign//sourceId:655220_1_28996
                }

                /*M3接收上文出参参数[5797]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getMgtType(), "D3查询评价模板当前特权管理状态-M3接收上文出参参数-管理类型不能为空", false);
                Assert.isNull(receptionServiceReq_2.getIsSuperMgt(), "D3查询评价模板当前特权管理状态-M3接收上文出参参数-是否超级管理不能为空", false);
                receptionServiceRes_3 = nbEvaTheme.implementAccessParameterBizField(receptionServiceReq_2);


                receptionServiceRes_1 = receptionServiceRes_3;
            }
        }
        QueryEvaTempPresentIsSuperMgtStateDetailRespDto retData = new QueryEvaTempPresentIsSuperMgtStateDetailRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setMgtType(receptionServiceRes_1.getMgtType());//SimpleFieldAssign//sourceId:655233_1
            retData.setIsSuperMgt(receptionServiceRes_1.getIsSuperMgt());//SimpleFieldAssign//sourceId:655234_1
        }


        return retData;
    }

    /**
     * D3执行评价模板新增条件判断(公共)[6410]
     * gen by moon at 5/1/2023, 10:17:48 PM
     */
    @Trace(operationName = "D3执行评价模板新增条件判断(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementEvaTempAddTermJudgeComRespDto implementEvaTempAddTermJudgeCom(ImplementEvaTempAddTermJudgeComReqDto reqDto) {


        ImplementAcceptFieldRespDto receptionServiceRes_3 = null;
//virtualUsage 3-2-02查主题下正在编辑的评价模板列表  38417
        List<OmsEvaluationTemplate> listOmsEvaluationTemplate = new ArrayList<>();
        QueryEvaTempListReq queryEvaTempListReq = new QueryEvaTempListReq();
        queryEvaTempListReq.setSubjectLifeCycle("EDITING");//sourceId:871923_1_38417
        queryEvaTempListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:871921_1_38417
        if (reqDto != null) {
            queryEvaTempListReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:871915_1_38417
        }

        /*3-2-02查主题下正在编辑的评价模板列表[2191]   */
        Assert.isNull(queryEvaTempListReq.getEvaluationSubjectId(), "D3执行评价模板新增条件判断(公共)-3-2-02查主题下正在编辑的评价模板列表-归属评价主题ID不能为空", false);
        Assert.isNull(queryEvaTempListReq.getSubjectLifeCycle(), "D3执行评价模板新增条件判断(公共)-3-2-02查主题下正在编辑的评价模板列表-主体生命周期不能为空", false);
        Assert.isNull(queryEvaTempListReq.getSpaceId(), "D3执行评价模板新增条件判断(公共)-3-2-02查主题下正在编辑的评价模板列表-创建于空间ID不能为空", false);
        listOmsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempList(queryEvaTempListReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((listOmsEvaluationTemplate != null && listOmsEvaluationTemplate != null && listOmsEvaluationTemplate.size() > 0)) {
            //if(3-2-02查主题下正在编辑的评价模板列表.评价模板列表数据集条数 大于 0)  38418

            List<OmsTarget> listOmsTarget = new ArrayList<>();
            if (listOmsEvaluationTemplate != null && !CollectionUtil.isEmpty(listOmsEvaluationTemplate) && listOmsEvaluationTemplate.size() > 0) {
                BatchQueryTargetListReq batchQueryTargetListReq = new BatchQueryTargetListReq();
                batchQueryTargetListReq.setDataInitStatus("FALSE");//sourceId:871930_1_38419
                batchQueryTargetListReq.setSubjectLifeCycle("EDITING");//sourceId:871929_1_38419
                if (listOmsEvaluationTemplate != null && !CollectionUtil.isEmpty(listOmsEvaluationTemplate) && listOmsEvaluationTemplate != null && !CollectionUtil.isEmpty(listOmsEvaluationTemplate)) {
                    batchQueryTargetListReq.setTargetList(listOmsEvaluationTemplate.stream().map(item -> item.getTargetId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:871925_1_38419
                }

                /*3-3-06批量查未公开的目标列表[2205]   */
                Assert.isNull(batchQueryTargetListReq.getDataInitStatus(), "D3执行评价模板新增条件判断(公共)-3-3-06批量查未公开的目标列表-数据初始化完成状态不能为空", false);
                Assert.isNull(batchQueryTargetListReq.getSubjectLifeCycle(), "D3执行评价模板新增条件判断(公共)-3-3-06批量查未公开的目标列表-主体生命周期不能为空", false);
                listOmsTarget = mOmsTargetService.batchQueryTargetList(batchQueryTargetListReq)/*vcase invoke 本地 method 方法调用;*/;


            }
            if ((listOmsTarget != null && listOmsTarget != null && listOmsTarget.size() == 0)) {
                //if(3-3-06批量查未公开的目标列表.目标列表数据集条数 等于 0)  38420

//ModelCode: receptionService
                ImplementAcceptFieldRespDto receptionServiceRes = null;
                ImplementAcceptFieldReqDto receptionServiceReq = new ImplementAcceptFieldReqDto();
                receptionServiceReq.setCustomField("1");//CUSTOM_CONVENTION//sourceId:872127_1_38421

                /*M3约定为允许新增评价模板[6100]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getCustomField(), "D3执行评价模板新增条件判断(公共)-M3约定为允许新增评价模板-自定义字段不能为空", false);
                receptionServiceRes = nbEvaTheme.implementAcceptField(receptionServiceReq);


//ModelCode: receptionService
                ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
                ImplementAcceptFieldReqDto receptionServiceReq_1 = new ImplementAcceptFieldReqDto();
                if (receptionServiceRes != null) {
                    receptionServiceReq_1.setCustomField(receptionServiceRes.getCustomField());//SimpleFieldAssign//sourceId:872589_1_38429
                }

                /*M3接收上文出参字段值[6100]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getCustomField(), "D3执行评价模板新增条件判断(公共)-M3接收上文出参字段值-自定义字段不能为空", false);
                receptionServiceRes_2 = nbEvaTheme.implementAcceptField(receptionServiceReq_1);


                receptionServiceRes_3 = receptionServiceRes_2;
            } else if ((listOmsTarget != null && listOmsTarget != null && listOmsTarget.size() > 0)) {
                //elseif(3-3-06批量查未公开的目标列表.目标列表数据集条数 大于 0)  38422

//ModelCode: receptionService
                ImplementAcceptFieldRespDto receptionServiceRes_4 = null;
                ImplementAcceptFieldReqDto receptionServiceReq_2 = new ImplementAcceptFieldReqDto();
                receptionServiceReq_2.setCustomField("0");//CUSTOM_CONVENTION//sourceId:872586_1_38424

                /*M3约定为不允许新增评价模板[6100]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getCustomField(), "D3执行评价模板新增条件判断(公共)-M3约定为不允许新增评价模板-自定义字段不能为空", false);
                receptionServiceRes_4 = nbEvaTheme.implementAcceptField(receptionServiceReq_2);


//ModelCode: receptionService
                ImplementAcceptFieldRespDto receptionServiceRes_6 = null;
                ImplementAcceptFieldReqDto receptionServiceReq_3 = new ImplementAcceptFieldReqDto();
                if (receptionServiceRes_4 != null) {
                    receptionServiceReq_3.setCustomField(receptionServiceRes_4.getCustomField());//SimpleFieldAssign//sourceId:872589_1_38428
                }

                /*M3接收上文出参字段值[6100]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_3.getCustomField(), "D3执行评价模板新增条件判断(公共)-M3接收上文出参字段值-自定义字段不能为空", false);
                receptionServiceRes_6 = nbEvaTheme.implementAcceptField(receptionServiceReq_3);


                receptionServiceRes_3 = receptionServiceRes_6;
            }
        } else if ((listOmsEvaluationTemplate != null && listOmsEvaluationTemplate != null && listOmsEvaluationTemplate.size() == 0)) {
            //elseif(3-2-02查主题下正在编辑的评价模板列表.评价模板列表数据集条数 等于 0)  38425

//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes_7 = null;
            ImplementAcceptFieldReqDto receptionServiceReq_4 = new ImplementAcceptFieldReqDto();
            receptionServiceReq_4.setCustomField("1");//CUSTOM_CONVENTION//sourceId:872127_1_38426

            /*M3约定为允许新增评价模板[6100]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_4.getCustomField(), "D3执行评价模板新增条件判断(公共)-M3约定为允许新增评价模板-自定义字段不能为空", false);
            receptionServiceRes_7 = nbEvaTheme.implementAcceptField(receptionServiceReq_4);


//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes_8 = null;
            ImplementAcceptFieldReqDto receptionServiceReq_5 = new ImplementAcceptFieldReqDto();
            if (receptionServiceRes_7 != null) {
                receptionServiceReq_5.setCustomField(receptionServiceRes_7.getCustomField());//SimpleFieldAssign//sourceId:872589_1_38427
            }

            /*M3接收上文出参字段值[6100]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_5.getCustomField(), "D3执行评价模板新增条件判断(公共)-M3接收上文出参字段值-自定义字段不能为空", false);
            receptionServiceRes_8 = nbEvaTheme.implementAcceptField(receptionServiceReq_5);


            receptionServiceRes_3 = receptionServiceRes_8;
        }
        ImplementEvaTempAddTermJudgeComRespDto retData = new ImplementEvaTempAddTermJudgeComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setIsAddEvaTemp(receptionServiceRes_3.getCustomField());//SimpleFieldAssign//sourceId:872590_1
        }


        return retData;
    }

    /**
     * D3新增评价模板开通记录[6481]
     * gen by moon at 1/19/2024, 6:29:34 PM
     */
    @Trace(operationName = "D3新增评价模板开通记录")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddEvaTempOpenRecordRespDto addEvaTempOpenRecord(AddEvaTempOpenRecordReqDto reqDto) {


        AddOpenRecordAuthorizationComRespDto addOpenRecordAuthorizationComRespDto_1 = null;
//virtualUsage 3-2-02查评价模板详情  39928
        OmsEvaluationTemplate omsEvaluationTemplate = null;
        QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
        queryEvaTempDetailReq.setArchivngType("NOT_ARCHIVE");//sourceId:895833_1_39928
        queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:895816_1_39928
        if (reqDto != null) {
            queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:895810_1_39928
        }

        /*3-2-02查评价模板详情[2316]   */
        Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(), "D3新增评价模板开通记录-3-2-02查评价模板详情-评价模板ID不能为空", false);
        Assert.isNull(queryEvaTempDetailReq.getArchivngType(), "D3新增评价模板开通记录-3-2-02查评价模板详情-存档类型不能为空", false);
        Assert.isNull(queryEvaTempDetailReq.getIsArchive(), "D3新增评价模板开通记录-3-2-02查评价模板详情-是否存档不能为空", false);
        omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage D2-3查评价模板配置方案信息  39939
        QueryConfSchemeDetailComRespDto queryConfSchemeDetailComRespDto = null;
        if (omsEvaluationTemplate != null) {
            QueryConfSchemeDetailComReqDto queryConfSchemeDetailComReqDto = new QueryConfSchemeDetailComReqDto();
            queryConfSchemeDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:895953_1_39939
            if (omsEvaluationTemplate != null) {
                queryConfSchemeDetailComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:941172_1_39939
            }

            /*D2-3查评价模板配置方案信息[1981]   */
            Assert.isNull(queryConfSchemeDetailComReqDto.getConfSchemeId(), "D3新增评价模板开通记录-D2-3查评价模板配置方案信息-配置方案ID 不能为空", false);
            Assert.isNull(queryConfSchemeDetailComReqDto.getSubjectLifeCycle(), "D3新增评价模板开通记录-D2-3查评价模板配置方案信息-生命周期状态不能为空", false);
            queryConfSchemeDetailComRespDto = confSchemeService.queryConfSchemeDetailCom(queryConfSchemeDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage 3-3查目标父周期  39941
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:896029_1_39941
        queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:896030_1_39941
        queryEvaObjTargetCycleDetailReq.setTargetCycleContentTypeCode("TARGET");//sourceId:896031_1_39941
        queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:896032_1_39941
        queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:896034_1_39941
        queryEvaObjTargetCycleDetailReq.setArchivngType("NOT_ARCHIVE");//sourceId:896035_1_39941
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:896033_1_39941
        }

        /*3-3查目标父周期[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(), "D3新增评价模板开通记录-3-3查目标父周期-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(), "D3新增评价模板开通记录-3-3查目标父周期-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentTypeCode(), "D3新增评价模板开通记录-3-3查目标父周期-关联目标内容类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(), "D3新增评价模板开通记录-3-3查目标父周期-是否父周期不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3新增评价模板开通记录-3-3查目标父周期-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3新增评价模板开通记录-3-3查目标父周期-是否存档不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getArchivngType(), "D3新增评价模板开通记录-3-3查目标父周期-存档类型不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage D2新增开通记录并授权(公共)  39922
        AddOpenRecordAuthorizationComRespDto addOpenRecordAuthorizationComRespDto = null;
        if (queryConfSchemeDetailComRespDto != null && omsEvaluationObjectTargetCycle != null && omsEvaluationTemplate != null) {
            AddOpenRecordAuthorizationComReqDto addOpenRecordAuthorizationComReqDto = new AddOpenRecordAuthorizationComReqDto();
            addOpenRecordAuthorizationComReqDto.setAuthType("FIXED_TIME");//sourceId:895622_1_39922
            addOpenRecordAuthorizationComReqDto.setIsMainConfScheme("TRUE");//sourceId:895627_1_39922
            addOpenRecordAuthorizationComReqDto.setApplexType("EVA_TEMP");//sourceId:895630_1_39922
            addOpenRecordAuthorizationComReqDto.setTenantSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:895628_1_39922
            addOpenRecordAuthorizationComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:895629_1_39922
            if (queryConfSchemeDetailComRespDto != null) {
                addOpenRecordAuthorizationComReqDto.setConfSchemeId(queryConfSchemeDetailComRespDto.getConfSchemeId());//SimpleFieldAssign//sourceId:895620_1_39922
                addOpenRecordAuthorizationComReqDto.setConfSchemeCode(queryConfSchemeDetailComRespDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:895621_1_39922
            }
            if (omsEvaluationObjectTargetCycle != null) {
                addOpenRecordAuthorizationComReqDto.setStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:895625_1_39922
                addOpenRecordAuthorizationComReqDto.setEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:895626_1_39922
                addOpenRecordAuthorizationComReqDto.setApplexName(omsEvaluationObjectTargetCycle.getTargetCycleName());//SimpleFieldAssign//sourceId:915059_1_39922
            }
            if (omsEvaluationTemplate != null) {
                addOpenRecordAuthorizationComReqDto.setAuthorizationKeyTypeCode(omsEvaluationTemplate.getTargetPlanTempSubtype());//SimpleFieldAssign//sourceId:932176_1_39922
            }
            if (reqDto != null) {
                addOpenRecordAuthorizationComReqDto.setApplexId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:895631_1_39922
            }

            /*D2新增开通记录并授权(公共)[3102]   */
            Assert.isNull(addOpenRecordAuthorizationComReqDto.getConfSchemeId(), "D3新增评价模板开通记录-D2新增开通记录并授权(公共)-配置方案ID 不能为空", false);
            Assert.isNull(addOpenRecordAuthorizationComReqDto.getConfSchemeCode(), "D3新增评价模板开通记录-D2新增开通记录并授权(公共)-配置方案标识不能为空", false);
            Assert.isNull(addOpenRecordAuthorizationComReqDto.getAuthType(), "D3新增评价模板开通记录-D2新增开通记录并授权(公共)-授权类型不能为空", false);
            Assert.isNull(addOpenRecordAuthorizationComReqDto.getStartTime(), "D3新增评价模板开通记录-D2新增开通记录并授权(公共)-开始时间不能为空", false);
            Assert.isNull(addOpenRecordAuthorizationComReqDto.getEndTime(), "D3新增评价模板开通记录-D2新增开通记录并授权(公共)-结束时间不能为空", false);
            Assert.isNull(addOpenRecordAuthorizationComReqDto.getIsMainConfScheme(), "D3新增评价模板开通记录-D2新增开通记录并授权(公共)-是否主配置方案不能为空", false);
            Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexType(), "D3新增评价模板开通记录-D2新增开通记录并授权(公共)-开通对象类型编码不能为空", false);
            Assert.isNull(addOpenRecordAuthorizationComReqDto.getAuthorizationKeyTypeCode(), "D3新增评价模板开通记录-D2新增开通记录并授权(公共)-开通钥匙类型标识不能为空", false);
            Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexId(), "D3新增评价模板开通记录-D2新增开通记录并授权(公共)-开通对象ID不能为空", false);
            Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexName(), "D3新增评价模板开通记录-D2新增开通记录并授权(公共)-冗余开通对象名称不能为空", false);
            Assert.isNull(addOpenRecordAuthorizationComReqDto.getTenantSpaceId(), "D3新增评价模板开通记录-D2新增开通记录并授权(公共)-租户空间ID不能为空", false);
            Assert.isNull(addOpenRecordAuthorizationComReqDto.getSubjectLifeCycle(), "D3新增评价模板开通记录-D2新增开通记录并授权(公共)-主体生命周期不能为空", false);
            addOpenRecordAuthorizationComRespDto = fwCompSchemeOpenRecordClient.addOpenRecordAuthorizationCom(addOpenRecordAuthorizationComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            addOpenRecordAuthorizationComRespDto_1 = addOpenRecordAuthorizationComRespDto;
        }
//virtualUsage 3-2-01查评价主题配置方案ID  39932
        OmsEvaluationSubject omsEvaluationSubject = null;
        if (omsEvaluationTemplate != null) {
            QueryEvaThemeDetailReq queryEvaThemeDetailReq = new QueryEvaThemeDetailReq();
            queryEvaThemeDetailReq.setAscriptionSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:895643_1_39932
            if (omsEvaluationTemplate != null) {
                queryEvaThemeDetailReq.setEvaluationSubjectId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:895650_1_39932
            }

            /*3-2-01查评价主题配置方案ID[2310]   */
            Assert.isNull(queryEvaThemeDetailReq.getEvaluationSubjectId(), "D3新增评价模板开通记录-3-2-01查评价主题配置方案ID-评价主题ID不能为空", false);
            Assert.isNull(queryEvaThemeDetailReq.getAscriptionSpaceId(), "D3新增评价模板开通记录-3-2-01查评价主题配置方案ID-归属空间ID不能为空", false);
            omsEvaluationSubject = mOmsEvaluationSubjectService.queryEvaThemeDetail(queryEvaThemeDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        }
//virtualUsage D2执行更新开通记录(公共)  39933
        ImplementUpdateSchOpenRecordComRespDto implementUpdateSchOpenRecordComRespDto = null;
        if (omsEvaluationSubject != null) {
            ImplementUpdateSchOpenRecordComReqDto implementUpdateSchOpenRecordComReqDto = new ImplementUpdateSchOpenRecordComReqDto();
            implementUpdateSchOpenRecordComReqDto.setTenantSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:895640_1_39933
            implementUpdateSchOpenRecordComReqDto.setCustomField1("ADD");//CUSTOM_CONVENTION//sourceId:895638_1_39933
            if (omsEvaluationSubject != null) {
                implementUpdateSchOpenRecordComReqDto.setConfSchemeId(omsEvaluationSubject.getConfSchemeId());//SimpleFieldAssign//sourceId:895639_1_39933
            }

            /*D2执行更新开通记录(公共)[6468]   */
            Assert.isNull(implementUpdateSchOpenRecordComReqDto.getConfSchemeId(), "D3新增评价模板开通记录-D2执行更新开通记录(公共)-配置方案ID 不能为空", false);
            Assert.isNull(implementUpdateSchOpenRecordComReqDto.getTenantSpaceId(), "D3新增评价模板开通记录-D2执行更新开通记录(公共)-租户空间ID不能为空", false);
            Assert.isNull(implementUpdateSchOpenRecordComReqDto.getCustomField1(), "D3新增评价模板开通记录-D2执行更新开通记录(公共)-更新操作场景不能为空", false);
            implementUpdateSchOpenRecordComRespDto = fwCompSchemeOpenRecordClient.implementUpdateSchOpenRecordCom(implementUpdateSchOpenRecordComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        AddEvaTempOpenRecordRespDto retData = new AddEvaTempOpenRecordRespDto();
        if (addOpenRecordAuthorizationComRespDto_1 != null) {
            retData.setSchOpenRecordId(addOpenRecordAuthorizationComRespDto_1.getSchOpenRecordId());//SimpleFieldAssign//sourceId:895859_1
            retData.setApplexRelId(addOpenRecordAuthorizationComRespDto_1.getApplexRelId());//SimpleFieldAssign//sourceId:895860_1
        }


        return retData;
    }

    /**
     * D3发布批次处理评价画像相关更新状态(公共)[7170]
     * gen by moon at 6/9/2023, 8:51:09 PM
     */
    @Trace(operationName = "D3发布批次处理评价画像相关更新状态(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ReleaseBatchHandleEvaPortraitRelatedUpdStatusComRespDto releaseBatchHandleEvaPortraitRelatedUpdStatusCom(ReleaseBatchHandleEvaPortraitRelatedUpdStatusComReqDto reqDto) {


        //virtualUsage 3-2-04查批次下是否有本次新增的评价画像  44893
        OmsEvaluationPortrait omsEvaluationPortrait = null;
        QueryEvaPortraitDetailReq queryEvaPortraitDetailReq = new QueryEvaPortraitDetailReq();
        queryEvaPortraitDetailReq.setUpdateStatus("NEW");//sourceId:1028367_1_44893
        if (reqDto != null) {
            queryEvaPortraitDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028365_1_44893
            queryEvaPortraitDetailReq.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1028369_1_44893
        }

        /*3-2-04查批次下是否有本次新增的评价画像[2408]   */
        Assert.isNull(queryEvaPortraitDetailReq.getEvaluationTemplateId(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-04查批次下是否有本次新增的评价画像-评价模板ID不能为空", false);
        Assert.isNull(queryEvaPortraitDetailReq.getUpdateStatus(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-04查批次下是否有本次新增的评价画像-批次下更新状态不能为空", false);
        Assert.isNull(queryEvaPortraitDetailReq.getBatchCode(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-04查批次下是否有本次新增的评价画像-批次标识不能为空", false);
        omsEvaluationPortrait = mOmsEvaluationPortraitService.queryEvaPortraitDetail(queryEvaPortraitDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsEvaluationPortrait != null)) {
            //if(3-2-04查批次下是否有本次新增的评价画像.出参 值不等于空 )  44894

            boolean bOOLEAN;
            if (omsEvaluationPortrait != null) {
                OmsEvaluationPortrait omsEvaluationPortrait_2 = new OmsEvaluationPortrait();
                omsEvaluationPortrait_2.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1028382_1_44895
                omsEvaluationPortrait_2.setIsUpdate("FALSE");//sourceId:1028383_1_44895
                omsEvaluationPortrait_2.setUpdateStatus("UNCHANGED");//sourceId:1028384_1_44895
                omsEvaluationPortrait_2.setIsEditing("FALSE");//sourceId:1028385_1_44895
                omsEvaluationPortrait_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1028386_1_44895
                omsEvaluationPortrait_2.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1028387_1_44895
                omsEvaluationPortrait_2.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1028388_1_44895
                omsEvaluationPortrait_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1028389_1_44895
                omsEvaluationPortrait_2.setReleaseTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1028390_1_44895
                if (omsEvaluationPortrait != null) {
                    omsEvaluationPortrait_2.setEvaluationPortraitId(omsEvaluationPortrait.getEvaluationPortraitId());//SimpleFieldAssign//sourceId:1028381_1_44895
                }

                /*3-2-04修改评价画像为当前有效[7171]   */
                Assert.isNull(omsEvaluationPortrait_2.getEvaluationPortraitId(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-评价画像ID不能为空", false);
                Assert.isNull(omsEvaluationPortrait_2.getBatchStartTime(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-批次开始时间不能为空", false);
                Assert.isNull(omsEvaluationPortrait_2.getIsUpdate(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-批次下是否更新不能为空", false);
                Assert.isNull(omsEvaluationPortrait_2.getUpdateStatus(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-批次下更新状态不能为空", false);
                Assert.isNull(omsEvaluationPortrait_2.getSubjectLifeCycle(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-主体生命周期不能为空", false);
                Assert.isNull(omsEvaluationPortrait_2.getOperationInductionId(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-操作人就职记录ID不能为空", false);
                Assert.isNull(omsEvaluationPortrait_2.getReleaseInductionId(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-发布人就职记录ID不能为空", false);
                Assert.isNull(omsEvaluationPortrait_2.getOperateTime(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-操作时间不能为空", false);
                Assert.isNull(omsEvaluationPortrait_2.getReleaseTime(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-发布时间不能为空", false);
                bOOLEAN = mOmsEvaluationPortraitService.updateEvaPortrait(omsEvaluationPortrait_2)/*vcase invoke 本地 method 方法调用;*/;


            }
        }
//virtualUsage 3-2-05查询评价对象列表  44896
        List<OmsEvaluationObject> listOmsEvaluationObject = new ArrayList<>();
        QueryEvaObjectListReq queryEvaObjectListReq = new QueryEvaObjectListReq();
        queryEvaObjectListReq.setUpdateStatus("NEW");//sourceId:1028402_1_44896
        if (reqDto != null) {
            queryEvaObjectListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028400_1_44896
            queryEvaObjectListReq.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1028401_1_44896
        }

        /*3-2-05查询评价对象列表[7172]   */
        Assert.isNull(queryEvaObjectListReq.getEvaluationTemplateId(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-05查询评价对象列表-评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjectListReq.getBatchCode(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-05查询评价对象列表-批次标识不能为空", false);
        Assert.isNull(queryEvaObjectListReq.getUpdateStatus(), "D3发布批次处理评价画像相关更新状态(公共)-3-2-05查询评价对象列表-批次下更新状态不能为空", false);
        listOmsEvaluationObject = mOmsEvaluationObjectService.queryEvaObjectList(queryEvaObjectListReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((listOmsEvaluationObject != null && listOmsEvaluationObject != null && listOmsEvaluationObject.size() > 0)) {
            //if(3-2-05查批次下是否有本次新增的评价对象列表.评价对象列表数据集条数 大于 0)  44897

            boolean bOOLEAN_1;
            if (listOmsEvaluationObject != null && !CollectionUtil.isEmpty(listOmsEvaluationObject) && listOmsEvaluationObject.size() > 0) {
                List<OmsEvaluationObject> listOmsEvaluationObject_2 = new ArrayList<>();
                if (listOmsEvaluationObject != null && !CollectionUtil.isEmpty(listOmsEvaluationObject) && listOmsEvaluationObject != null && !CollectionUtil.isEmpty(listOmsEvaluationObject)) {
                    listOmsEvaluationObject_2 = //objList-to-objLists
                            listOmsEvaluationObject.stream().map(item -> {
                                OmsEvaluationObject elm = new OmsEvaluationObject();
                                elm.setEvaluationObjectId(item.getEvaluationObjectId());//SimpleFieldAssign//sourceId:218610_2_44898
                                elm.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:218611_2_44898
                                elm.setIsUpdate("FALSE");//sourceId:218612_2_44898
                                elm.setUpdateStatus("UNCHANGED");//sourceId:218613_2_44898
                                elm.setIsEditing("FALSE");//sourceId:218614_2_44898
                                elm.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:218615_2_44898
                                elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:218616_2_44898
                                elm.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:218617_2_44898
                                elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:218618_2_44898
                                elm.setReleaseTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:218619_2_44898
                                return elm;
                            }).collect(Collectors.toList());//objList-to-objLists//sourceId:1028405_1_44898
                }

                /*3-2-05批量改评价对象发布生效[7173]   */

                bOOLEAN_1 = mOmsEvaluationObjectService.batchUpdateEvaObject(listOmsEvaluationObject_2)/*vcase invoke 本地 method 方法调用;*/;


            }
        }
        ReleaseBatchHandleEvaPortraitRelatedUpdStatusComRespDto retData = new ReleaseBatchHandleEvaPortraitRelatedUpdStatusComRespDto();


        return retData;
    }

    /**
     * D3发布批次处理评价填报角色更新状态(公共)[7174]
     * gen by moon at 6/9/2023, 8:51:23 PM
     */
    @Trace(operationName = "D3发布批次处理评价填报角色更新状态(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ReleaseBatchHandleEvaFillRoleUpdStatusComRespDto releaseBatchHandleEvaFillRoleUpdStatusCom(ReleaseBatchHandleEvaFillRoleUpdStatusComReqDto reqDto) {


        //virtualUsage 3-2-06查批次下是否有本次新增的评价填报角色列表  44899
        List<OmsEvaluationFillRole> listOmsEvaluationFillRole = new ArrayList<>();
        QueryEvaFillRoleListReq queryEvaFillRoleListReq = new QueryEvaFillRoleListReq();
        queryEvaFillRoleListReq.setUpdateStatus("NEW");//sourceId:1028416_1_44899
        if (reqDto != null) {
            queryEvaFillRoleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028409_1_44899
            queryEvaFillRoleListReq.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1028417_1_44899
        }

        /*3-2-06查批次下是否有本次新增的评价填报角色列表[2369]   */
        Assert.isNull(queryEvaFillRoleListReq.getEvaluationTemplateId(), "D3发布批次处理评价填报角色更新状态(公共)-3-2-06查批次下是否有本次新增的评价填报角色列表-评价模板ID不能为空", false);
        Assert.isNull(queryEvaFillRoleListReq.getBatchCode(), "D3发布批次处理评价填报角色更新状态(公共)-3-2-06查批次下是否有本次新增的评价填报角色列表-批次标识不能为空", false);
        Assert.isNull(queryEvaFillRoleListReq.getUpdateStatus(), "D3发布批次处理评价填报角色更新状态(公共)-3-2-06查批次下是否有本次新增的评价填报角色列表-批次下更新状态不能为空", false);
        listOmsEvaluationFillRole = mOmsEvaluationFillRoleService.queryEvaFillRoleList(queryEvaFillRoleListReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((listOmsEvaluationFillRole != null && listOmsEvaluationFillRole != null && listOmsEvaluationFillRole.size() > 0)) {
            //if(3-2-06查评价填报角色列表.评价填报角色列表数据集条数 大于 0)  44900

            boolean bOOLEAN;
            if (listOmsEvaluationFillRole != null && !CollectionUtil.isEmpty(listOmsEvaluationFillRole) && listOmsEvaluationFillRole.size() > 0) {
                List<OmsEvaluationFillRole> listOmsEvaluationFillRole_2 = new ArrayList<>();
                if (listOmsEvaluationFillRole != null && !CollectionUtil.isEmpty(listOmsEvaluationFillRole) && listOmsEvaluationFillRole != null && !CollectionUtil.isEmpty(listOmsEvaluationFillRole)) {
                    listOmsEvaluationFillRole_2 = //objList-to-objLists
                            listOmsEvaluationFillRole.stream().map(item -> {
                                OmsEvaluationFillRole elm = new OmsEvaluationFillRole();
                                elm.setEvaluationFillRoleId(item.getEvaluationFillRoleId());//SimpleFieldAssign//sourceId:218634_2_44902
                                elm.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:218635_2_44902
                                elm.setIsUpdate("FALSE");//sourceId:218636_2_44902
                                elm.setUpdateStatus("UNCHANGED");//sourceId:218637_2_44902
                                elm.setIsEditing("FALSE");//sourceId:218638_2_44902
                                elm.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:218639_2_44902
                                elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:218640_2_44902
                                elm.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:218641_2_44902
                                elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:218642_2_44902
                                elm.setReleaseTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:218643_2_44902
                                return elm;
                            }).collect(Collectors.toList());//objList-to-objLists//sourceId:1028430_1_44902
                }

                /*3-2-06批量改评价填报角色发布生效[7175]   */

                bOOLEAN = mOmsEvaluationFillRoleService.batchUpdateEvaFillRole(listOmsEvaluationFillRole_2)/*vcase invoke 本地 method 方法调用;*/;


            }
        }
        ReleaseBatchHandleEvaFillRoleUpdStatusComRespDto retData = new ReleaseBatchHandleEvaFillRoleUpdStatusComRespDto();


        return retData;
    }

    /**
     * D3查询评价模板列表(公共)(边界)[7388]
     * gen by moon at 9/13/2023, 10:37:22 PM
     */
    @Trace(operationName = "D3查询评价模板列表(公共)(边界)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaTempListComBorderRespDto queryEvaTempListComBorder(QueryEvaTempListComBorderReqDto reqDto) {


        List<OmsEvaluationTemplate> listOmsEvaluationTemplate_1 = new ArrayList<>();
//步骤0: 3-2-02查评价模板列表 - queryEvaTempList
        List<OmsEvaluationTemplate> listOmsEvaluationTemplate = new ArrayList<>();
        QueryEvaTempListReq queryEvaTempListReq = new QueryEvaTempListReq();
        if (reqDto != null) {
            queryEvaTempListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1120439_1
        }

        /*3-2-02查评价模板列表[2191]   */
        Assert.isNull(queryEvaTempListReq.getDeptId(), "D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-牵头部门ID不能为空", false);
        Assert.isNull(queryEvaTempListReq.getEvaluationSubjectId(), "D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-归属评价主题ID不能为空", false);
        Assert.isNull(queryEvaTempListReq.getTargetId(), "D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-对应的目标ID不能为空", false);
        Assert.isNull(queryEvaTempListReq.getConfSchemeCode(), "D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-冗余配置方案标识不能为空", false);
        Assert.isNull(queryEvaTempListReq.getEvaluationTemplateTypeCode(), "D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-冗余评价模板类型配置项不能为空", false);
        Assert.isNull(queryEvaTempListReq.getIsOkrPlanScene(), "D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-冗余开启OKR场景配置项不能为空", false);
        Assert.isNull(queryEvaTempListReq.getEvaluationSubjectTypeCode(), "D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-冗余评价主题类型配置项不能为空", false);
        Assert.isNull(queryEvaTempListReq.getBizSceneCode(), "D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-冗余业务场景标识配置项不能为空", false);
        Assert.isNull(queryEvaTempListReq.getIsArchive(), "D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-是否存档不能为空", false);
        Assert.isNull(queryEvaTempListReq.getSubjectLifeCycle(), "D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-主体生命周期不能为空", false);
        Assert.isNull(queryEvaTempListReq.getSpaceId(), "D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-创建于空间ID不能为空", false);
        listOmsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempList(queryEvaTempListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsEvaluationTemplate_1 = listOmsEvaluationTemplate;

        QueryEvaTempListComBorderRespDto retData = new QueryEvaTempListComBorderRespDto();
        if (listOmsEvaluationTemplate_1 != null && !CollectionUtil.isEmpty(listOmsEvaluationTemplate_1) && listOmsEvaluationTemplate_1 != null && !CollectionUtil.isEmpty(listOmsEvaluationTemplate_1)) {
            retData.setEvalTempList(listOmsEvaluationTemplate_1.stream().map(item -> item.getEvaluationTemplateId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:1120441_1
        }


        return retData;
    }

    /**
     * D3获取空间有效评价模板(公共)[7872]
     * gen by moon at 11/10/2023, 3:23:22 PM
     */
    @Trace(operationName = "D3获取空间有效评价模板(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainSpaceValidEvaTempComRespDto obtainSpaceValidEvaTempCom(ObtainSpaceValidEvaTempComReqDto reqDto) {


        OmsTarget omsTarget_1 = null;
        List<OmsTarget> listOmsTarget_1 = new ArrayList<>();
//virtualUsage 3-3-01查常规规划进行中的评价模板  52779
        OmsTarget omsTarget = null;
        QueryTargetDetailReq queryTargetDetailReq = new QueryTargetDetailReq();
        queryTargetDetailReq.setTargetPgsStatus("ONGOING");//sourceId:1284210_1_52779
        queryTargetDetailReq.setPlanningType("GENERAL_PLANNING");//sourceId:1284248_1_52779
        queryTargetDetailReq.setBizSceneCode("STRATEGY_PLAN_SCENE");//CUSTOM_CONVENTION//sourceId:1284249_1_52779
        queryTargetDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1284212_1_52779

        /*3-3-01查常规规划进行中的评价模板[2488]   */
        Assert.isNull(queryTargetDetailReq.getTargetPgsStatus(), "D3获取空间有效评价模板(公共)-3-3-01查常规规划进行中的评价模板-目标进展状态不能为空", false);
        Assert.isNull(queryTargetDetailReq.getPlanningType(), "D3获取空间有效评价模板(公共)-3-3-01查常规规划进行中的评价模板-冗余规划类型不能为空", false);
        Assert.isNull(queryTargetDetailReq.getBizSceneCode(), "D3获取空间有效评价模板(公共)-3-3-01查常规规划进行中的评价模板-冗余业务场景标识配置项不能为空", false);
        Assert.isNull(queryTargetDetailReq.getSubjectLifeCycle(), "D3获取空间有效评价模板(公共)-3-3-01查常规规划进行中的评价模板-主体生命周期不能为空", false);
        omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsTarget_1 = omsTarget;
        if ((omsTarget == null)) {
            //if(3-3-01查常规规划进行中的评价模板.出参 值等于空 )  52780

            List<OmsTarget> listOmsTarget = new ArrayList<>();
            QueryTargetListReq queryTargetListReq = new QueryTargetListReq();
            queryTargetListReq.setTargetPgsStatus("ONGOING");//sourceId:1284415_1_52781
            queryTargetListReq.setBizSceneCode("STRATEGY_PLAN_SCENE");//CUSTOM_CONVENTION//sourceId:1284416_1_52781
            queryTargetListReq.setPlanningType("THEMATIC_PLANNING");//sourceId:1284417_1_52781
            queryTargetListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1284418_1_52781
            queryTargetListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1284419_1_52781

            /*3-3-06查专题规划进行中的评价模板列表[2452]   */
            Assert.isNull(queryTargetListReq.getTargetPgsStatus(), "D3获取空间有效评价模板(公共)-3-3-06查专题规划进行中的评价模板列表-目标进展状态不能为空", false);
            Assert.isNull(queryTargetListReq.getBizSceneCode(), "D3获取空间有效评价模板(公共)-3-3-06查专题规划进行中的评价模板列表-冗余业务场景标识配置项不能为空", false);
            Assert.isNull(queryTargetListReq.getPlanningType(), "D3获取空间有效评价模板(公共)-3-3-06查专题规划进行中的评价模板列表-冗余规划类型不能为空", false);
            Assert.isNull(queryTargetListReq.getSubjectLifeCycle(), "D3获取空间有效评价模板(公共)-3-3-06查专题规划进行中的评价模板列表-主体生命周期不能为空", false);
            Assert.isNull(queryTargetListReq.getSpaceId(), "D3获取空间有效评价模板(公共)-3-3-06查专题规划进行中的评价模板列表-创建于空间ID不能为空", false);
            listOmsTarget = mOmsTargetService.queryTargetList(queryTargetListReq)/*vcase invoke 本地 method 方法调用;*/;


            listOmsTarget_1 = listOmsTarget;
        }
        ObtainSpaceValidEvaTempComRespDto retData = new ObtainSpaceValidEvaTempComRespDto();
        if (listOmsTarget_1 != null && !CollectionUtil.isEmpty(listOmsTarget_1) && listOmsTarget_1 != null && !CollectionUtil.isEmpty(listOmsTarget_1)) {
            retData.setSubjectEvaTempList(listOmsTarget_1.stream().map(item -> item.getEvaluationTemplateId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:1284420_1
        }
        if (omsTarget_1 != null) {
            retData.setEvaluationTemplateId(omsTarget_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1284421_1
        }


        return retData;
    }

    /**
     * D3查询评价模板详情(公共)[8468]
     * gen by moon at 12/31/2024, 6:36:40 AM
     */
    @Trace(operationName = "D3查询评价模板详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaTempDetailComRespDto queryEvaTempDetailCom(QueryEvaTempDetailComReqDto reqDto) {


        OmsEvaluationTemplate omsEvaluationTemplate_1 = null;
//步骤0: 3-2-02查评价模板详情 - queryEvaTempDetail
        OmsEvaluationTemplate omsEvaluationTemplate = null;
        QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
        if (reqDto != null) {
            queryEvaTempDetailReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1532342_1
            queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1532343_1
            queryEvaTempDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1532344_1
            queryEvaTempDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1532345_1
            queryEvaTempDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1532346_1
        }

        /*3-2-02查评价模板详情[2316]   */

        omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsEvaluationTemplate_1 = omsEvaluationTemplate;

        QueryEvaTempDetailComRespDto retData = new QueryEvaTempDetailComRespDto();
        if (omsEvaluationTemplate_1 != null) {
            retData.setEvaluationTemplateId(omsEvaluationTemplate_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1532356_1
            retData.setEvaluationTempName(omsEvaluationTemplate_1.getEvaluationTempName());//SimpleFieldAssign//sourceId:2037869_1
            retData.setEvaluationTempShortName(omsEvaluationTemplate_1.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:2037870_1
            retData.setEvaluationSubjectId(omsEvaluationTemplate_1.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1532357_1
            retData.setIsOpenBudget(omsEvaluationTemplate_1.getIsOpenBudget());//SimpleFieldAssign//sourceId:1532358_1
            retData.setIsOpenBudgetReport(omsEvaluationTemplate_1.getIsOpenBudgetReport());//SimpleFieldAssign//sourceId:1532359_1
            retData.setConfSchemeId(omsEvaluationTemplate_1.getConfSchemeId());//SimpleFieldAssign//sourceId:1764586_1
        }


        return retData;
    }

    /**
     * D3-2批量查询评价模板(公共)[3074]
     * gen by moon at 12/31/2024, 2:11:06 AM
     */
    @Trace(operationName = "D3-2批量查询评价模板(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryEvaTempComRespDto batchQueryEvaTempCom(BatchQueryEvaTempComReqDto reqDto) {


        List<OmsEvaluationTemplate> listOmsEvaluationTemplate_1 = new ArrayList<>();
//步骤0: 3-2-02批量查询评价模板 - batchQueryEvaTemp
        List<OmsEvaluationTemplate> listOmsEvaluationTemplate = new ArrayList<>();
        BatchQueryEvaTempReq batchQueryEvaTempReq = new BatchQueryEvaTempReq();
        if (reqDto != null) {
            batchQueryEvaTempReq.setEvalTempList(reqDto.getEvalTempList());//list-field-assign//sourceId:104157_1
            batchQueryEvaTempReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:258697_1
        }

        /*3-2-02批量查询评价模板[3075]   */

        listOmsEvaluationTemplate = mOmsEvaluationTemplateService.batchQueryEvaTemp(batchQueryEvaTempReq)/*vcase invoke 本地 method 方法调用;*/;


        listOmsEvaluationTemplate_1 = listOmsEvaluationTemplate;

        BatchQueryEvaTempComRespDto retData = new BatchQueryEvaTempComRespDto();
        retData.setEvalTempList(listOmsEvaluationTemplate_1.stream().map(item -> BeanUtil.toBean(item, EvalTempDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:104162_1


        return retData;
    }

    //
}
